diff --git a/.github/workflows/examples-nrfconnect.yaml b/.github/workflows/examples-nrfconnect.yaml
index 77a8ec626ba56a..bd90f5248605d4 100644
--- a/.github/workflows/examples-nrfconnect.yaml
+++ b/.github/workflows/examples-nrfconnect.yaml
@@ -193,6 +193,13 @@ jobs:
nrfconnect nrf7002dk_nrf5340_cpuapp all-clusters-app \
examples/all-clusters-app/nrfconnect/build/nrfconnect/zephyr/zephyr.elf \
/tmp/bloat_reports/
+ - name: Build example nRF Connect SDK Manufacturer Specific App on nRF52840 DK
+ run: |
+ scripts/examples/nrfconnect_example.sh manufacturer-specific-app nrf52840dk/nrf52840
+ .environment/pigweed-venv/bin/python3 scripts/tools/memory/gh_sizes.py \
+ nrfconnect nrf52840dk_nrf52840 manufacturer-specific-app \
+ examples/manufacturer-specific-app/nrfconnect/build/nrfconnect/zephyr/zephyr.elf \
+ /tmp/bloat_reports/
- name: Run unit tests for Zephyr native_posix_64 platform
if: github.event_name == 'push' || steps.changed_paths.outputs.tests == 'true' || steps.changed_paths.outputs.nrfconnect == 'true'
run: |
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 786fee684002a3..5fef2021336ff3 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -277,7 +277,14 @@ jobs:
type-safe getters
if: always()
run: |
- git grep -I -n 'emberAfReadAttribute' -- './*' ':(exclude).github/workflows/lint.yml' ':(exclude)src/app/util/attribute-table.h' ':(exclude)zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' ':(exclude)src/app/zap-templates/templates/app/attributes/Accessors-src.zapt' ':(exclude)src/app/util/attribute-table.cpp' && exit 1 || exit 0
+ git grep -I -n 'emberAfReadAttribute' -- './*' \
+ ':(exclude).github/workflows/lint.yml' \
+ ':(exclude)src/app/util/attribute-table.h' \
+ ':(exclude)zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' \
+ ':(exclude)examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' \
+ ':(exclude)src/app/zap-templates/templates/app/attributes/Accessors-src.zapt' \
+ ':(exclude)src/app/util/attribute-table.cpp' \
+ && exit 1 || exit 0
# git grep exits with 0 if it finds a match, but we want
# to fail (exit nonzero) on match. And we want to exclude this file,
@@ -292,8 +299,8 @@ jobs:
git grep -I -n 'emberAfWriteAttribute' -- './*' \
':(exclude).github/workflows/lint.yml' \
':(exclude)examples/common/pigweed/rpc_services/Attributes.h' \
- ':(exclude)src/data-model-providers/codegen/CodegenDataModelProvider_Write.cpp' \
- ':(exclude)src/data-model-providers/codegen/tests/EmberReadWriteOverride.cpp' \
+ ':(exclude)src/data-model-providers/codegen/CodegenDataModelProvider_Write.cpp' \
+ ':(exclude)src/data-model-providers/codegen/tests/EmberReadWriteOverride.cpp' \
':(exclude)src/app/dynamic_server/DynamicDispatcher.cpp' \
':(exclude)src/app/util/attribute-table.cpp' \
':(exclude)src/app/util/attribute-table.h' \
@@ -301,6 +308,7 @@ jobs:
':(exclude)src/app/zap-templates/templates/app/attributes/Accessors-src.zapt' \
':(exclude)src/darwin/Framework/CHIP/ServerEndpoint/MTRIMDispatch.mm' \
':(exclude)zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' \
+ ':(exclude)examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' \
&& exit 1 || exit 0
# Run ruff python linter
diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml
index 1ed2a01bdbc018..424171e9cc080f 100644
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@@ -210,7 +210,7 @@ jobs:
src/app/zap-templates/zcl/data-model/chip/temperature-control-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/matter-devices.xml \
src/app/zap-templates/zcl/data-model/chip/resource-monitoring-cluster.xml \
- src/app/zap-templates/zcl/data-model/chip/sample-mei-cluster.xml \
+ src/app/zap-templates/zcl/data-model/chip/sample-manufacturer-specific-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/electrical-energy-measurement-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/electrical-power-measurement-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/zone-management-cluster.xml \
diff --git a/build/chip/chip_codegen.cmake b/build/chip/chip_codegen.cmake
index 3a9c744cb39bdc..fe08711b457afb 100644
--- a/build/chip/chip_codegen.cmake
+++ b/build/chip/chip_codegen.cmake
@@ -118,6 +118,7 @@ endfunction()
# Arguments:
# INPUT - the name of the ".zap" file to use for generation
# GENERATOR - generator to use, like "app-templates"
+# TEMPLATES_JSON -
# OUTPUTS - EXPECTED output names
#
# OUTPUT_PATH - [OUT] output variable will contain the directory where the
@@ -129,7 +130,7 @@ endfunction()
function(chip_zapgen TARGET_NAME)
cmake_parse_arguments(ARG
""
- "INPUT;GENERATOR;OUTPUT_PATH;OUTPUT_FILES"
+ "INPUT;GENERATOR;OUTPUT_PATH;OUTPUT_FILES;TEMPLATES_JSON"
"OUTPUTS"
${ARGN}
)
@@ -147,14 +148,18 @@ function(chip_zapgen TARGET_NAME)
CONTENT "${OUTPUT_AS_NEWLINES}"
)
-
set(OUT_NAMES)
foreach(NAME IN LISTS ARG_OUTPUTS)
list(APPEND OUT_NAMES "${GEN_FOLDER}/${NAME}")
endforeach()
if ("${ARG_GENERATOR}" STREQUAL "app-templates")
- SET(TEMPLATE_PATH "${CHIP_ROOT}/src/app/zap-templates/app-templates.json")
+
+ if ("${ARG_TEMPLATES_JSON}" STREQUAL "")
+ SET(TEMPLATE_PATH "${CHIP_ROOT}/src/app/zap-templates/app-templates.json")
+ else()
+ SET(TEMPLATE_PATH "${ARG_TEMPLATES_JSON}")
+ endif()
# TODO: unclear how to maintain these: there is no parser that can figure
# out links of template files and zap files and such
diff --git a/config/common/cmake/chip_gn.cmake b/config/common/cmake/chip_gn.cmake
index c652bd4f486212..5dcaefa6645525 100644
--- a/config/common/cmake/chip_gn.cmake
+++ b/config/common/cmake/chip_gn.cmake
@@ -164,7 +164,6 @@ macro(matter_build target)
${CHIP_ROOT}/third_party/nlassert/repo/include
${CHIP_ROOT}/third_party/nlio/repo/include
${CHIP_ROOT}/third_party/nlfaultinjection/include
- ${CHIP_ROOT}/zzz_generated/app-common
${CMAKE_CURRENT_BINARY_DIR}/gen/include
)
diff --git a/config/common/cmake/chip_gn_args.cmake b/config/common/cmake/chip_gn_args.cmake
index 7d86d1fb433fdf..7afba423857118 100644
--- a/config/common/cmake/chip_gn_args.cmake
+++ b/config/common/cmake/chip_gn_args.cmake
@@ -161,6 +161,7 @@ endmacro()
# DEVICE_INFO_EXAMPLE_PROVIDER Add example device info provider support
# PROJECT_CONFIG Path to the project-specific configuration file
# PROJECT_CONFIG_INC_DIR Extra include dirs for project configurations
+# PROJECT_APP_COMMON_INC_DIR Extra include dir for custom app-common
#
macro(matter_common_gn_args)
set(options)
@@ -171,6 +172,7 @@ macro(matter_common_gn_args)
LIB_PW_RPC
DEVICE_INFO_EXAMPLE_PROVIDER
PROJECT_CONFIG
+ PROJECT_APP_COMMON_INC_DIR
)
set(multiValueArgs
PROJECT_CONFIG_INC_DIR
@@ -215,6 +217,14 @@ macro(matter_common_gn_args)
if (ARG_PROJECT_CONFIG_INC_DIR)
matter_add_gn_arg_list("chip_project_config_include_dirs" ${ARG_PROJECT_CONFIG_INC_DIR})
endif()
+ if (ARG_PROJECT_APP_COMMON_INC_DIR)
+ get_filename_component(PROJECT_APP_COMMON_INC_DIR
+ ${ARG_PROJECT_APP_COMMON_INC_DIR}
+ REALPATH
+ BASE_DIR ${CMAKE_SOURCE_DIR}
+ )
+ matter_add_gn_arg_string("chip_project_app_common_include_dir" "${PROJECT_APP_COMMON_INC_DIR}")
+ endif()
endmacro()
# Generate the temporary GN arguments file from the settings
diff --git a/config/nrfconnect/chip-module/CMakeLists.txt b/config/nrfconnect/chip-module/CMakeLists.txt
index 448287f0ecd4cf..48d03ce7bda4b7 100644
--- a/config/nrfconnect/chip-module/CMakeLists.txt
+++ b/config/nrfconnect/chip-module/CMakeLists.txt
@@ -115,6 +115,7 @@ matter_common_gn_args(
LIB_SHELL CONFIG_CHIP_LIB_SHELL
LIB_TESTS CONFIG_CHIP_BUILD_TESTS
PROJECT_CONFIG ${CONFIG_CHIP_PROJECT_CONFIG}
+ PROJECT_APP_COMMON_INC_DIR ${CONFIG_CHIP_PROJECT_APP_COMMON_INCLUDE_DIRS}
DEVICE_INFO_EXAMPLE_PROVIDER CONFIG_CHIP_EXAMPLE_DEVICE_INFO_PROVIDER
)
matter_add_gn_arg_string("zephyr_ar" ${CMAKE_AR})
diff --git a/config/telink/chip-module/CMakeLists.txt b/config/telink/chip-module/CMakeLists.txt
index 0f925cdeffc904..1554049dae857b 100644
--- a/config/telink/chip-module/CMakeLists.txt
+++ b/config/telink/chip-module/CMakeLists.txt
@@ -86,6 +86,7 @@ matter_common_gn_args(
LIB_SHELL CONFIG_CHIP_LIB_SHELL
LIB_TESTS CONFIG_CHIP_BUILD_TESTS
PROJECT_CONFIG ${CONFIG_CHIP_PROJECT_CONFIG}
+ PROJECT_APP_COMMON_INC_DIR ${CONFIG_CHIP_PROJECT_APP_COMMON_INCLUDE_DIRS}
DEVICE_INFO_EXAMPLE_PROVIDER CONFIG_CHIP_EXAMPLE_DEVICE_INFO_PROVIDER
)
matter_add_gn_arg_string("zephyr_ar" ${CMAKE_AR})
diff --git a/config/zephyr/Kconfig b/config/zephyr/Kconfig
index 7b0ee1d15062d5..3a3b77a2a661a7 100644
--- a/config/zephyr/Kconfig
+++ b/config/zephyr/Kconfig
@@ -316,6 +316,11 @@ config CHIP_PROJECT_CONFIG
configuration file that can be used to override any of Matter's default or
platform-specific settings.
+config CHIP_PROJECT_APP_COMMON_INCLUDE_DIRS
+ string "Project specific app-common directory for Manufacturer-specific clusters"
+ help
+ Provides a directory to the app-common/ folder.
+
# Thread network features
config CHIP_ENABLE_DNSSD_SRP
diff --git a/docs/examples/manufacturer_specific.md b/docs/examples/manufacturer_specific.md
new file mode 100644
index 00000000000000..80c9d95ef38800
--- /dev/null
+++ b/docs/examples/manufacturer_specific.md
@@ -0,0 +1,8 @@
+## Manufacturer specific cluster
+
+```{toctree}
+:glob:
+:maxdepth: 1
+
+manufacturer-specific-app/**/README
+```
diff --git a/docs/ids_and_codes/zap_clusters.md b/docs/ids_and_codes/zap_clusters.md
index a805a9436c29dd..b58ece494c76d8 100644
--- a/docs/ids_and_codes/zap_clusters.md
+++ b/docs/ids_and_codes/zap_clusters.md
@@ -139,4 +139,4 @@ Generally regenerate using one of:
| 1873 | 0x751 | CommissionerControl |
| 4294048773 | 0xFFF1FC05 | UnitTesting |
| 4294048774 | 0xFFF1FC06 | FaultInjection |
-| 4294048800 | 0xFFF1FC20 | SampleMei |
+| 4294048800 | 0xFFF1FC20 | SampleManufacturerSpecific |
diff --git a/examples/chef/README.md b/examples/chef/README.md
index 4e1db9bf7dbff3..e52924b10c1e4f 100644
--- a/examples/chef/README.md
+++ b/examples/chef/README.md
@@ -235,9 +235,9 @@ To add new devices for chef:
## Manufacturer Extensions / Custom Clusters
You may add vendor-defined features to chef. The
-`rootnode_onofflight_meisample*` device showcases its usage by using the Sample
-MEI cluster which is defined on
-`src/app/zap-templates/zcl/data-model/chip/sample-mei-cluster.xml`
+`rootnode_onofflight_manufacturer_specific_sample*` device showcases its usage
+by using the Sample Manufacturer-specific cluster which is defined in
+`src/app/zap-templates/zcl/data-model/chip/sample-manufacturer-specific-cluster.xml`
This cluster has
@@ -246,15 +246,16 @@ This cluster has
- A command/response pair `add-arguments`. The command takes two uint8
arguments and the response command returns their sum.
-You may test the `Sample MEI` via chip-tool using the following commands:
+You may test the `Sample Manufacturer Specific Cluster` via chip-tool using the
+following commands:
```
# commissioning of on-network chef device
chip-tool pairing onnetwork 1 20202021
# tests command to sum arguments: returns 30
-chip-tool samplemei add-arguments 1 1 10 20
+chip-tool sample-manufacturer-specific add-arguments 1 1 10 20
# sets Flip-Flop to false
-chip-tool samplemei write flip-flop 0 1 1
+chip-tool sample-manufacturer-specific write flip-flop 0 1 1
# reads Flip-Flop
-chip-tool samplemei read flip-flop 1 1
+chip-tool sample-manufacturer-specific read flip-flop 1 1
```
diff --git a/examples/chef/devices/rootnode_onofflight_samplemei.matter b/examples/chef/devices/rootnode_onofflight_manufacturer_specific_sample.matter
similarity index 99%
rename from examples/chef/devices/rootnode_onofflight_samplemei.matter
rename to examples/chef/devices/rootnode_onofflight_manufacturer_specific_sample.matter
index 174f5c119469fa..565c8dd97dd8a3 100644
--- a/examples/chef/devices/rootnode_onofflight_samplemei.matter
+++ b/examples/chef/devices/rootnode_onofflight_manufacturer_specific_sample.matter
@@ -1755,8 +1755,8 @@ cluster FixedLabel = 64 {
readonly attribute int16u clusterRevision = 65533;
}
-/** The Sample MEI cluster showcases a cluster manufacturer extensions */
-cluster SampleMei = 4294048800 {
+/** A manufacturer-specific sample cluster */
+cluster SampleManufacturerSpecific = 4294048800 {
revision 1; // NOTE: Default/not specifically set
fabric_sensitive info event PingCountEvent = 0 {
@@ -2082,7 +2082,7 @@ endpoint 1 {
callback attribute clusterRevision;
}
- server cluster SampleMei {
+ server cluster SampleManufacturerSpecific {
emits event PingCountEvent;
ram attribute flipFlop default = false;
callback attribute generatedCommandList;
diff --git a/examples/chef/devices/rootnode_onofflight_samplemei.zap b/examples/chef/devices/rootnode_onofflight_manufacturer_specific_sample.zap
similarity index 99%
rename from examples/chef/devices/rootnode_onofflight_samplemei.zap
rename to examples/chef/devices/rootnode_onofflight_manufacturer_specific_sample.zap
index 23543f053ded81..e435bc53aedd9b 100644
--- a/examples/chef/devices/rootnode_onofflight_samplemei.zap
+++ b/examples/chef/devices/rootnode_onofflight_manufacturer_specific_sample.zap
@@ -3258,10 +3258,10 @@
"enabled": 1
},
{
- "name": "Sample MEI",
+ "name": "Sample Manufacturer-Specific",
"code": 4294048800,
"mfgCode": null,
- "define": "SAMPLE_MEI_CLUSTER",
+ "define": "SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER",
"side": "server",
"enabled": 1,
"commands": [
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/BUILD.gn b/examples/manufacturer-specific-app/manufacturer-specific-common/BUILD.gn
new file mode 100644
index 00000000000000..eb24b69dd214e1
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/BUILD.gn
@@ -0,0 +1,42 @@
+# Copyright (c) 2020 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build_overrides/chip.gni")
+import("${chip_root}/src/app/chip_data_model.gni")
+
+config("config") {
+ include_dirs = [ "include" ]
+}
+
+chip_data_model("lighting-common") {
+ zap_file = "lighting-app.zap"
+ is_server = true
+}
+
+source_set("color-format") {
+ public_configs = [ ":config" ]
+ sources = [
+ "include/ColorFormat.h",
+ "src/ColorFormat.cpp",
+ ]
+}
+
+source_set("lighting-manager") {
+ deps = [ "${chip_root}/src/lib" ]
+ public_configs = [ ":config" ]
+ sources = [
+ "include/LightingManager.h",
+ "src/LightingManager.cpp",
+ ]
+}
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/include/ColorFormat.h b/examples/manufacturer-specific-app/manufacturer-specific-common/include/ColorFormat.h
new file mode 100755
index 00000000000000..1ad0cb0e75f4f4
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/include/ColorFormat.h
@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright (c) 2021 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+struct RgbColor_t
+{
+ uint8_t r;
+ uint8_t g;
+ uint8_t b;
+};
+
+struct HsvColor_t
+{
+ uint8_t h;
+ uint8_t s;
+ uint8_t v;
+};
+
+struct XyColor_t
+{
+ uint16_t x;
+ uint16_t y;
+};
+
+struct CtColor_t
+{
+ uint16_t ctMireds;
+};
+
+RgbColor_t XYToRgb(uint8_t Level, uint16_t currentX, uint16_t currentY);
+RgbColor_t HsvToRgb(HsvColor_t hsv);
+RgbColor_t CTToRgb(CtColor_t ct);
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/include/LightingManager.h b/examples/manufacturer-specific-app/manufacturer-specific-common/include/LightingManager.h
new file mode 100644
index 00000000000000..bf4b885f7c47a9
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/include/LightingManager.h
@@ -0,0 +1,67 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <functional>
+
+#include <lib/core/CHIPError.h>
+
+class LightingManager
+{
+public:
+ enum Action_t
+ {
+ ON_ACTION = 0,
+ OFF_ACTION,
+ INVALID_ACTION
+ } Action;
+
+ enum State_t
+ {
+ kState_On = 0,
+ kState_Off,
+ } State;
+
+ CHIP_ERROR Init();
+ bool IsTurnedOn();
+ bool InitiateAction(Action_t aAction);
+
+ using LightingCallback_fn = std::function<void(Action_t)>;
+
+ void SetCallbacks(LightingCallback_fn aActionInitiated_CB, LightingCallback_fn aActionCompleted_CB);
+
+private:
+ friend LightingManager & LightingMgr(void);
+ State_t mState;
+
+ LightingCallback_fn mActionInitiated_CB;
+ LightingCallback_fn mActionCompleted_CB;
+
+ void Set(bool aOn);
+
+ static LightingManager sLight;
+};
+
+inline LightingManager & LightingMgr(void)
+{
+ return LightingManager::sLight;
+}
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/manufacturer-specific-app.matter b/examples/manufacturer-specific-app/manufacturer-specific-common/manufacturer-specific-app.matter
new file mode 100644
index 00000000000000..6e3cf475413908
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/manufacturer-specific-app.matter
@@ -0,0 +1,3114 @@
+// This IDL was generated automatically by ZAP.
+// It is for view/code review purposes only.
+
+enum AreaTypeTag : enum8 {
+ kAisle = 0;
+ kAttic = 1;
+ kBackDoor = 2;
+ kBackYard = 3;
+ kBalcony = 4;
+ kBallroom = 5;
+ kBathroom = 6;
+ kBedroom = 7;
+ kBorder = 8;
+ kBoxroom = 9;
+ kBreakfastRoom = 10;
+ kCarport = 11;
+ kCellar = 12;
+ kCloakroom = 13;
+ kCloset = 14;
+ kConservatory = 15;
+ kCorridor = 16;
+ kCraftRoom = 17;
+ kCupboard = 18;
+ kDeck = 19;
+ kDen = 20;
+ kDining = 21;
+ kDrawingRoom = 22;
+ kDressingRoom = 23;
+ kDriveway = 24;
+ kElevator = 25;
+ kEnsuite = 26;
+ kEntrance = 27;
+ kEntryway = 28;
+ kFamilyRoom = 29;
+ kFoyer = 30;
+ kFrontDoor = 31;
+ kFrontYard = 32;
+ kGameRoom = 33;
+ kGarage = 34;
+ kGarageDoor = 35;
+ kGarden = 36;
+ kGardenDoor = 37;
+ kGuestBathroom = 38;
+ kGuestBedroom = 39;
+ kGuestRestroom = 40;
+ kGuestRoom = 41;
+ kGym = 42;
+ kHallway = 43;
+ kHearthRoom = 44;
+ kKidsRoom = 45;
+ kKidsBedroom = 46;
+ kKitchen = 47;
+ kLarder = 48;
+ kLaundryRoom = 49;
+ kLawn = 50;
+ kLibrary = 51;
+ kLivingRoom = 52;
+ kLounge = 53;
+ kMediaTVRoom = 54;
+ kMudRoom = 55;
+ kMusicRoom = 56;
+ kNursery = 57;
+ kOffice = 58;
+ kOutdoorKitchen = 59;
+ kOutside = 60;
+ kPantry = 61;
+ kParkingLot = 62;
+ kParlor = 63;
+ kPatio = 64;
+ kPlayRoom = 65;
+ kPoolRoom = 66;
+ kPorch = 67;
+ kPrimaryBathroom = 68;
+ kPrimaryBedroom = 69;
+ kRamp = 70;
+ kReceptionRoom = 71;
+ kRecreationRoom = 72;
+ kRestroom = 73;
+ kRoof = 74;
+ kSauna = 75;
+ kScullery = 76;
+ kSewingRoom = 77;
+ kShed = 78;
+ kSideDoor = 79;
+ kSideYard = 80;
+ kSittingRoom = 81;
+ kSnug = 82;
+ kSpa = 83;
+ kStaircase = 84;
+ kSteamRoom = 85;
+ kStorageRoom = 86;
+ kStudio = 87;
+ kStudy = 88;
+ kSunRoom = 89;
+ kSwimmingPool = 90;
+ kTerrace = 91;
+ kUtilityRoom = 92;
+ kWard = 93;
+ kWorkshop = 94;
+}
+
+enum AtomicRequestTypeEnum : enum8 {
+ kBeginWrite = 0;
+ kCommitWrite = 1;
+ kRollbackWrite = 2;
+}
+
+enum FloorSurfaceTag : enum8 {
+ kCarpet = 0;
+ kCeramic = 1;
+ kConcrete = 2;
+ kCork = 3;
+ kDeepCarpet = 4;
+ kDirt = 5;
+ kEngineeredWood = 6;
+ kGlass = 7;
+ kGrass = 8;
+ kHardwood = 9;
+ kLaminate = 10;
+ kLinoleum = 11;
+ kMat = 12;
+ kMetal = 13;
+ kPlastic = 14;
+ kPolishedConcrete = 15;
+ kRubber = 16;
+ kRug = 17;
+ kSand = 18;
+ kStone = 19;
+ kTatami = 20;
+ kTerrazzo = 21;
+ kTile = 22;
+ kVinyl = 23;
+}
+
+enum LandmarkTag : enum8 {
+ kAirConditioner = 0;
+ kAirPurifier = 1;
+ kBackDoor = 2;
+ kBarStool = 3;
+ kBathMat = 4;
+ kBathtub = 5;
+ kBed = 6;
+ kBookshelf = 7;
+ kChair = 8;
+ kChristmasTree = 9;
+ kCoatRack = 10;
+ kCoffeeTable = 11;
+ kCookingRange = 12;
+ kCouch = 13;
+ kCountertop = 14;
+ kCradle = 15;
+ kCrib = 16;
+ kDesk = 17;
+ kDiningTable = 18;
+ kDishwasher = 19;
+ kDoor = 20;
+ kDresser = 21;
+ kLaundryDryer = 22;
+ kFan = 23;
+ kFireplace = 24;
+ kFreezer = 25;
+ kFrontDoor = 26;
+ kHighChair = 27;
+ kKitchenIsland = 28;
+ kLamp = 29;
+ kLitterBox = 30;
+ kMirror = 31;
+ kNightstand = 32;
+ kOven = 33;
+ kPetBed = 34;
+ kPetBowl = 35;
+ kPetCrate = 36;
+ kRefrigerator = 37;
+ kScratchingPost = 38;
+ kShoeRack = 39;
+ kShower = 40;
+ kSideDoor = 41;
+ kSink = 42;
+ kSofa = 43;
+ kStove = 44;
+ kTable = 45;
+ kToilet = 46;
+ kTrashCan = 47;
+ kLaundryWasher = 48;
+ kWindow = 49;
+ kWineCooler = 50;
+}
+
+enum PositionTag : enum8 {
+ kLeft = 0;
+ kRight = 1;
+ kTop = 2;
+ kBottom = 3;
+ kMiddle = 4;
+ kRow = 5;
+ kColumn = 6;
+}
+
+enum RelativePositionTag : enum8 {
+ kUnder = 0;
+ kNextTo = 1;
+ kAround = 2;
+ kOn = 3;
+ kAbove = 4;
+ kFrontOf = 5;
+ kBehind = 6;
+}
+
+enum TestGlobalEnum : enum8 {
+ kSomeValue = 0;
+ kSomeOtherValue = 1;
+ kFinalValue = 2;
+}
+
+enum ThreeLevelAutoEnum : enum8 {
+ kLow = 0;
+ kMedium = 1;
+ kHigh = 2;
+ kAutomatic = 3;
+}
+
+bitmap TestGlobalBitmap : bitmap32 {
+ kFirstBit = 0x1;
+ kSecondBit = 0x2;
+}
+
+struct TestGlobalStruct {
+ char_string<128> name = 0;
+ nullable TestGlobalBitmap myBitmap = 1;
+ optional nullable TestGlobalEnum myEnum = 2;
+}
+
+struct LocationDescriptorStruct {
+ char_string<128> locationName = 0;
+ nullable int16s floorNumber = 1;
+ nullable AreaTypeTag areaType = 2;
+}
+
+struct AtomicAttributeStatusStruct {
+ attrib_id attributeID = 0;
+ status statusCode = 1;
+}
+
+/** Attributes and commands for putting a device into Identification mode (e.g. flashing a light). */
+cluster Identify = 3 {
+ revision 4;
+
+ enum EffectIdentifierEnum : enum8 {
+ kBlink = 0;
+ kBreathe = 1;
+ kOkay = 2;
+ kChannelChange = 11;
+ kFinishEffect = 254;
+ kStopEffect = 255;
+ }
+
+ enum EffectVariantEnum : enum8 {
+ kDefault = 0;
+ }
+
+ enum IdentifyTypeEnum : enum8 {
+ kNone = 0;
+ kLightOutput = 1;
+ kVisibleIndicator = 2;
+ kAudibleBeep = 3;
+ kDisplay = 4;
+ kActuator = 5;
+ }
+
+ attribute int16u identifyTime = 0;
+ readonly attribute IdentifyTypeEnum identifyType = 1;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct IdentifyRequest {
+ int16u identifyTime = 0;
+ }
+
+ request struct TriggerEffectRequest {
+ EffectIdentifierEnum effectIdentifier = 0;
+ EffectVariantEnum effectVariant = 1;
+ }
+
+ /** Command description for Identify */
+ command access(invoke: manage) Identify(IdentifyRequest): DefaultSuccess = 0;
+ /** Command description for TriggerEffect */
+ command access(invoke: manage) TriggerEffect(TriggerEffectRequest): DefaultSuccess = 64;
+}
+
+/** Attributes and commands for group configuration and manipulation. */
+cluster Groups = 4 {
+ revision 4;
+
+ bitmap Feature : bitmap32 {
+ kGroupNames = 0x1;
+ }
+
+ bitmap NameSupportBitmap : bitmap8 {
+ kGroupNames = 0x80;
+ }
+
+ readonly attribute NameSupportBitmap nameSupport = 0;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct AddGroupRequest {
+ group_id groupID = 0;
+ char_string<16> groupName = 1;
+ }
+
+ response struct AddGroupResponse = 0 {
+ enum8 status = 0;
+ group_id groupID = 1;
+ }
+
+ request struct ViewGroupRequest {
+ group_id groupID = 0;
+ }
+
+ response struct ViewGroupResponse = 1 {
+ enum8 status = 0;
+ group_id groupID = 1;
+ char_string<16> groupName = 2;
+ }
+
+ request struct GetGroupMembershipRequest {
+ group_id groupList[] = 0;
+ }
+
+ response struct GetGroupMembershipResponse = 2 {
+ nullable int8u capacity = 0;
+ group_id groupList[] = 1;
+ }
+
+ request struct RemoveGroupRequest {
+ group_id groupID = 0;
+ }
+
+ response struct RemoveGroupResponse = 3 {
+ enum8 status = 0;
+ group_id groupID = 1;
+ }
+
+ request struct AddGroupIfIdentifyingRequest {
+ group_id groupID = 0;
+ char_string<16> groupName = 1;
+ }
+
+ /** Command description for AddGroup */
+ fabric command access(invoke: manage) AddGroup(AddGroupRequest): AddGroupResponse = 0;
+ /** Command description for ViewGroup */
+ fabric command ViewGroup(ViewGroupRequest): ViewGroupResponse = 1;
+ /** Command description for GetGroupMembership */
+ fabric command GetGroupMembership(GetGroupMembershipRequest): GetGroupMembershipResponse = 2;
+ /** Command description for RemoveGroup */
+ fabric command access(invoke: manage) RemoveGroup(RemoveGroupRequest): RemoveGroupResponse = 3;
+ /** Command description for RemoveAllGroups */
+ fabric command access(invoke: manage) RemoveAllGroups(): DefaultSuccess = 4;
+ /** Command description for AddGroupIfIdentifying */
+ fabric command access(invoke: manage) AddGroupIfIdentifying(AddGroupIfIdentifyingRequest): DefaultSuccess = 5;
+}
+
+/** Attributes and commands for switching devices between 'On' and 'Off' states. */
+cluster OnOff = 6 {
+ revision 6;
+
+ enum DelayedAllOffEffectVariantEnum : enum8 {
+ kDelayedOffFastFade = 0;
+ kNoFade = 1;
+ kDelayedOffSlowFade = 2;
+ }
+
+ enum DyingLightEffectVariantEnum : enum8 {
+ kDyingLightFadeOff = 0;
+ }
+
+ enum EffectIdentifierEnum : enum8 {
+ kDelayedAllOff = 0;
+ kDyingLight = 1;
+ }
+
+ enum StartUpOnOffEnum : enum8 {
+ kOff = 0;
+ kOn = 1;
+ kToggle = 2;
+ }
+
+ bitmap Feature : bitmap32 {
+ kLighting = 0x1;
+ kDeadFrontBehavior = 0x2;
+ kOffOnly = 0x4;
+ }
+
+ bitmap OnOffControlBitmap : bitmap8 {
+ kAcceptOnlyWhenOn = 0x1;
+ }
+
+ readonly attribute boolean onOff = 0;
+ readonly attribute optional boolean globalSceneControl = 16384;
+ attribute optional int16u onTime = 16385;
+ attribute optional int16u offWaitTime = 16386;
+ attribute access(write: manage) optional nullable StartUpOnOffEnum startUpOnOff = 16387;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct OffWithEffectRequest {
+ EffectIdentifierEnum effectIdentifier = 0;
+ enum8 effectVariant = 1;
+ }
+
+ request struct OnWithTimedOffRequest {
+ OnOffControlBitmap onOffControl = 0;
+ int16u onTime = 1;
+ int16u offWaitTime = 2;
+ }
+
+ /** On receipt of this command, a device SHALL enter its ‘Off’ state. This state is device dependent, but it is recommended that it is used for power off or similar functions. On receipt of the Off command, the OnTime attribute SHALL be set to 0. */
+ command Off(): DefaultSuccess = 0;
+ /** On receipt of this command, a device SHALL enter its ‘On’ state. This state is device dependent, but it is recommended that it is used for power on or similar functions. On receipt of the On command, if the value of the OnTime attribute is equal to 0, the device SHALL set the OffWaitTime attribute to 0. */
+ command On(): DefaultSuccess = 1;
+ /** On receipt of this command, if a device is in its ‘Off’ state it SHALL enter its ‘On’ state. Otherwise, if it is in its ‘On’ state it SHALL enter its ‘Off’ state. On receipt of the Toggle command, if the value of the OnOff attribute is equal to FALSE and if the value of the OnTime attribute is equal to 0, the device SHALL set the OffWaitTime attribute to 0. If the value of the OnOff attribute is equal to TRUE, the OnTime attribute SHALL be set to 0. */
+ command Toggle(): DefaultSuccess = 2;
+ /** The OffWithEffect command allows devices to be turned off using enhanced ways of fading. */
+ command OffWithEffect(OffWithEffectRequest): DefaultSuccess = 64;
+ /** The OnWithRecallGlobalScene command allows the recall of the settings when the device was turned off. */
+ command OnWithRecallGlobalScene(): DefaultSuccess = 65;
+ /** The OnWithTimedOff command allows devices to be turned on for a specific duration with a guarded off duration so that SHOULD the device be subsequently switched off, further OnWithTimedOff commands, received during this time, are prevented from turning the devices back on. */
+ command OnWithTimedOff(OnWithTimedOffRequest): DefaultSuccess = 66;
+}
+
+/** Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' */
+cluster LevelControl = 8 {
+ revision 6;
+
+ enum MoveModeEnum : enum8 {
+ kUp = 0;
+ kDown = 1;
+ }
+
+ enum StepModeEnum : enum8 {
+ kUp = 0;
+ kDown = 1;
+ }
+
+ bitmap Feature : bitmap32 {
+ kOnOff = 0x1;
+ kLighting = 0x2;
+ kFrequency = 0x4;
+ }
+
+ bitmap OptionsBitmap : bitmap8 {
+ kExecuteIfOff = 0x1;
+ kCoupleColorTempToLevel = 0x2;
+ }
+
+ readonly attribute nullable int8u currentLevel = 0;
+ readonly attribute optional int16u remainingTime = 1;
+ readonly attribute optional int8u minLevel = 2;
+ readonly attribute optional int8u maxLevel = 3;
+ readonly attribute optional int16u currentFrequency = 4;
+ readonly attribute optional int16u minFrequency = 5;
+ readonly attribute optional int16u maxFrequency = 6;
+ attribute OptionsBitmap options = 15;
+ attribute optional int16u onOffTransitionTime = 16;
+ attribute nullable int8u onLevel = 17;
+ attribute optional nullable int16u onTransitionTime = 18;
+ attribute optional nullable int16u offTransitionTime = 19;
+ attribute optional nullable int8u defaultMoveRate = 20;
+ attribute access(write: manage) optional nullable int8u startUpCurrentLevel = 16384;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct MoveToLevelRequest {
+ int8u level = 0;
+ nullable int16u transitionTime = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct MoveRequest {
+ MoveModeEnum moveMode = 0;
+ nullable int8u rate = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct StepRequest {
+ StepModeEnum stepMode = 0;
+ int8u stepSize = 1;
+ nullable int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct StopRequest {
+ OptionsBitmap optionsMask = 0;
+ OptionsBitmap optionsOverride = 1;
+ }
+
+ request struct MoveToLevelWithOnOffRequest {
+ int8u level = 0;
+ nullable int16u transitionTime = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct MoveWithOnOffRequest {
+ MoveModeEnum moveMode = 0;
+ nullable int8u rate = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct StepWithOnOffRequest {
+ StepModeEnum stepMode = 0;
+ int8u stepSize = 1;
+ nullable int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct StopWithOnOffRequest {
+ OptionsBitmap optionsMask = 0;
+ OptionsBitmap optionsOverride = 1;
+ }
+
+ request struct MoveToClosestFrequencyRequest {
+ int16u frequency = 0;
+ }
+
+ /** Command description for MoveToLevel */
+ command MoveToLevel(MoveToLevelRequest): DefaultSuccess = 0;
+ /** Command description for Move */
+ command Move(MoveRequest): DefaultSuccess = 1;
+ /** Command description for Step */
+ command Step(StepRequest): DefaultSuccess = 2;
+ /** Command description for Stop */
+ command Stop(StopRequest): DefaultSuccess = 3;
+ /** Command description for MoveToLevelWithOnOff */
+ command MoveToLevelWithOnOff(MoveToLevelWithOnOffRequest): DefaultSuccess = 4;
+ /** Command description for MoveWithOnOff */
+ command MoveWithOnOff(MoveWithOnOffRequest): DefaultSuccess = 5;
+ /** Command description for StepWithOnOff */
+ command StepWithOnOff(StepWithOnOffRequest): DefaultSuccess = 6;
+ /** Command description for StopWithOnOff */
+ command StopWithOnOff(StopWithOnOffRequest): DefaultSuccess = 7;
+ /** Change the currrent frequency to the provided one, or a close
+ approximation if the exact provided one is not possible. */
+ command MoveToClosestFrequency(MoveToClosestFrequencyRequest): DefaultSuccess = 8;
+}
+
+/** The Descriptor Cluster is meant to replace the support from the Zigbee Device Object (ZDO) for describing a node, its endpoints and clusters. */
+cluster Descriptor = 29 {
+ revision 2;
+
+ bitmap Feature : bitmap32 {
+ kTagList = 0x1;
+ }
+
+ struct DeviceTypeStruct {
+ devtype_id deviceType = 0;
+ int16u revision = 1;
+ }
+
+ struct SemanticTagStruct {
+ nullable vendor_id mfgCode = 0;
+ enum8 namespaceID = 1;
+ enum8 tag = 2;
+ optional nullable char_string label = 3;
+ }
+
+ readonly attribute DeviceTypeStruct deviceTypeList[] = 0;
+ readonly attribute cluster_id serverList[] = 1;
+ readonly attribute cluster_id clientList[] = 2;
+ readonly attribute endpoint_no partsList[] = 3;
+ readonly attribute optional SemanticTagStruct tagList[] = 4;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+}
+
+/** The Access Control Cluster exposes a data model view of a
+ Node's Access Control List (ACL), which codifies the rules used to manage
+ and enforce Access Control for the Node's endpoints and their associated
+ cluster instances. */
+cluster AccessControl = 31 {
+ revision 2;
+
+ enum AccessControlEntryAuthModeEnum : enum8 {
+ kPASE = 1;
+ kCASE = 2;
+ kGroup = 3;
+ }
+
+ enum AccessControlEntryPrivilegeEnum : enum8 {
+ kView = 1;
+ kProxyView = 2;
+ kOperate = 3;
+ kManage = 4;
+ kAdminister = 5;
+ }
+
+ enum AccessRestrictionTypeEnum : enum8 {
+ kAttributeAccessForbidden = 0;
+ kAttributeWriteForbidden = 1;
+ kCommandForbidden = 2;
+ kEventForbidden = 3;
+ }
+
+ enum ChangeTypeEnum : enum8 {
+ kChanged = 0;
+ kAdded = 1;
+ kRemoved = 2;
+ }
+
+ bitmap Feature : bitmap32 {
+ kExtension = 0x1;
+ kManagedDevice = 0x2;
+ }
+
+ struct AccessRestrictionStruct {
+ AccessRestrictionTypeEnum type = 0;
+ nullable int32u id = 1;
+ }
+
+ struct CommissioningAccessRestrictionEntryStruct {
+ endpoint_no endpoint = 0;
+ cluster_id cluster = 1;
+ AccessRestrictionStruct restrictions[] = 2;
+ }
+
+ fabric_scoped struct AccessRestrictionEntryStruct {
+ fabric_sensitive endpoint_no endpoint = 0;
+ fabric_sensitive cluster_id cluster = 1;
+ fabric_sensitive AccessRestrictionStruct restrictions[] = 2;
+ fabric_idx fabricIndex = 254;
+ }
+
+ struct AccessControlTargetStruct {
+ nullable cluster_id cluster = 0;
+ nullable endpoint_no endpoint = 1;
+ nullable devtype_id deviceType = 2;
+ }
+
+ fabric_scoped struct AccessControlEntryStruct {
+ fabric_sensitive AccessControlEntryPrivilegeEnum privilege = 1;
+ fabric_sensitive AccessControlEntryAuthModeEnum authMode = 2;
+ nullable fabric_sensitive int64u subjects[] = 3;
+ nullable fabric_sensitive AccessControlTargetStruct targets[] = 4;
+ fabric_idx fabricIndex = 254;
+ }
+
+ fabric_scoped struct AccessControlExtensionStruct {
+ fabric_sensitive octet_string<128> data = 1;
+ fabric_idx fabricIndex = 254;
+ }
+
+ fabric_sensitive info event access(read: administer) AccessControlEntryChanged = 0 {
+ nullable node_id adminNodeID = 1;
+ nullable int16u adminPasscodeID = 2;
+ ChangeTypeEnum changeType = 3;
+ nullable AccessControlEntryStruct latestValue = 4;
+ fabric_idx fabricIndex = 254;
+ }
+
+ fabric_sensitive info event access(read: administer) AccessControlExtensionChanged = 1 {
+ nullable node_id adminNodeID = 1;
+ nullable int16u adminPasscodeID = 2;
+ ChangeTypeEnum changeType = 3;
+ nullable AccessControlExtensionStruct latestValue = 4;
+ fabric_idx fabricIndex = 254;
+ }
+
+ fabric_sensitive info event access(read: administer) FabricRestrictionReviewUpdate = 2 {
+ int64u token = 0;
+ optional long_char_string instruction = 1;
+ optional long_char_string ARLRequestFlowUrl = 2;
+ fabric_idx fabricIndex = 254;
+ }
+
+ attribute access(read: administer, write: administer) AccessControlEntryStruct acl[] = 0;
+ attribute access(read: administer, write: administer) optional AccessControlExtensionStruct extension[] = 1;
+ readonly attribute int16u subjectsPerAccessControlEntry = 2;
+ readonly attribute int16u targetsPerAccessControlEntry = 3;
+ readonly attribute int16u accessControlEntriesPerFabric = 4;
+ readonly attribute optional CommissioningAccessRestrictionEntryStruct commissioningARL[] = 5;
+ readonly attribute optional AccessRestrictionEntryStruct arl[] = 6;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct ReviewFabricRestrictionsRequest {
+ CommissioningAccessRestrictionEntryStruct arl[] = 0;
+ }
+
+ response struct ReviewFabricRestrictionsResponse = 1 {
+ int64u token = 0;
+ }
+
+ /** This command signals to the service associated with the device vendor that the fabric administrator would like a review of the current restrictions on the accessing fabric. */
+ fabric command access(invoke: administer) ReviewFabricRestrictions(ReviewFabricRestrictionsRequest): ReviewFabricRestrictionsResponse = 0;
+}
+
+/** This cluster provides attributes and events for determining basic information about Nodes, which supports both
+ Commissioning and operational determination of Node characteristics, such as Vendor ID, Product ID and serial number,
+ which apply to the whole Node. Also allows setting user device information such as location. */
+cluster BasicInformation = 40 {
+ revision 3;
+
+ enum ColorEnum : enum8 {
+ kBlack = 0;
+ kNavy = 1;
+ kGreen = 2;
+ kTeal = 3;
+ kMaroon = 4;
+ kPurple = 5;
+ kOlive = 6;
+ kGray = 7;
+ kBlue = 8;
+ kLime = 9;
+ kAqua = 10;
+ kRed = 11;
+ kFuchsia = 12;
+ kYellow = 13;
+ kWhite = 14;
+ kNickel = 15;
+ kChrome = 16;
+ kBrass = 17;
+ kCopper = 18;
+ kSilver = 19;
+ kGold = 20;
+ }
+
+ enum ProductFinishEnum : enum8 {
+ kOther = 0;
+ kMatte = 1;
+ kSatin = 2;
+ kPolished = 3;
+ kRugged = 4;
+ kFabric = 5;
+ }
+
+ struct CapabilityMinimaStruct {
+ int16u caseSessionsPerFabric = 0;
+ int16u subscriptionsPerFabric = 1;
+ }
+
+ struct ProductAppearanceStruct {
+ ProductFinishEnum finish = 0;
+ nullable ColorEnum primaryColor = 1;
+ }
+
+ critical event StartUp = 0 {
+ int32u softwareVersion = 0;
+ }
+
+ critical event ShutDown = 1 {
+ }
+
+ info event Leave = 2 {
+ fabric_idx fabricIndex = 0;
+ }
+
+ info event ReachableChanged = 3 {
+ boolean reachableNewValue = 0;
+ }
+
+ readonly attribute int16u dataModelRevision = 0;
+ readonly attribute char_string<32> vendorName = 1;
+ readonly attribute vendor_id vendorID = 2;
+ readonly attribute char_string<32> productName = 3;
+ readonly attribute int16u productID = 4;
+ attribute access(write: manage) char_string<32> nodeLabel = 5;
+ attribute access(write: administer) char_string<2> location = 6;
+ readonly attribute int16u hardwareVersion = 7;
+ readonly attribute char_string<64> hardwareVersionString = 8;
+ readonly attribute int32u softwareVersion = 9;
+ readonly attribute char_string<64> softwareVersionString = 10;
+ readonly attribute optional char_string<16> manufacturingDate = 11;
+ readonly attribute optional char_string<32> partNumber = 12;
+ readonly attribute optional long_char_string<256> productURL = 13;
+ readonly attribute optional char_string<64> productLabel = 14;
+ readonly attribute optional char_string<32> serialNumber = 15;
+ attribute access(write: manage) optional boolean localConfigDisabled = 16;
+ readonly attribute optional boolean reachable = 17;
+ readonly attribute char_string<32> uniqueID = 18;
+ readonly attribute CapabilityMinimaStruct capabilityMinima = 19;
+ readonly attribute optional ProductAppearanceStruct productAppearance = 20;
+ readonly attribute int32u specificationVersion = 21;
+ readonly attribute int16u maxPathsPerInvoke = 22;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ command MfgSpecificPing(): DefaultSuccess = 0;
+}
+
+/** Provides an interface for providing OTA software updates */
+cluster OtaSoftwareUpdateProvider = 41 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum ApplyUpdateActionEnum : enum8 {
+ kProceed = 0;
+ kAwaitNextAction = 1;
+ kDiscontinue = 2;
+ }
+
+ enum DownloadProtocolEnum : enum8 {
+ kBDXSynchronous = 0;
+ kBDXAsynchronous = 1;
+ kHTTPS = 2;
+ kVendorSpecific = 3;
+ }
+
+ enum StatusEnum : enum8 {
+ kUpdateAvailable = 0;
+ kBusy = 1;
+ kNotAvailable = 2;
+ kDownloadProtocolNotSupported = 3;
+ }
+
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct QueryImageRequest {
+ vendor_id vendorID = 0;
+ int16u productID = 1;
+ int32u softwareVersion = 2;
+ DownloadProtocolEnum protocolsSupported[] = 3;
+ optional int16u hardwareVersion = 4;
+ optional char_string<2> location = 5;
+ optional boolean requestorCanConsent = 6;
+ optional octet_string<512> metadataForProvider = 7;
+ }
+
+ response struct QueryImageResponse = 1 {
+ StatusEnum status = 0;
+ optional int32u delayedActionTime = 1;
+ optional char_string<256> imageURI = 2;
+ optional int32u softwareVersion = 3;
+ optional char_string<64> softwareVersionString = 4;
+ optional octet_string<32> updateToken = 5;
+ optional boolean userConsentNeeded = 6;
+ optional octet_string<512> metadataForRequestor = 7;
+ }
+
+ request struct ApplyUpdateRequestRequest {
+ octet_string<32> updateToken = 0;
+ int32u newVersion = 1;
+ }
+
+ response struct ApplyUpdateResponse = 3 {
+ ApplyUpdateActionEnum action = 0;
+ int32u delayedActionTime = 1;
+ }
+
+ request struct NotifyUpdateAppliedRequest {
+ octet_string<32> updateToken = 0;
+ int32u softwareVersion = 1;
+ }
+
+ /** Determine availability of a new Software Image */
+ command QueryImage(QueryImageRequest): QueryImageResponse = 0;
+ /** Determine next action to take for a downloaded Software Image */
+ command ApplyUpdateRequest(ApplyUpdateRequestRequest): ApplyUpdateResponse = 2;
+ /** Notify OTA Provider that an update was applied */
+ command NotifyUpdateApplied(NotifyUpdateAppliedRequest): DefaultSuccess = 4;
+}
+
+/** Provides an interface for downloading and applying OTA software updates */
+cluster OtaSoftwareUpdateRequestor = 42 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum AnnouncementReasonEnum : enum8 {
+ kSimpleAnnouncement = 0;
+ kUpdateAvailable = 1;
+ kUrgentUpdateAvailable = 2;
+ }
+
+ enum ChangeReasonEnum : enum8 {
+ kUnknown = 0;
+ kSuccess = 1;
+ kFailure = 2;
+ kTimeOut = 3;
+ kDelayByProvider = 4;
+ }
+
+ enum UpdateStateEnum : enum8 {
+ kUnknown = 0;
+ kIdle = 1;
+ kQuerying = 2;
+ kDelayedOnQuery = 3;
+ kDownloading = 4;
+ kApplying = 5;
+ kDelayedOnApply = 6;
+ kRollingBack = 7;
+ kDelayedOnUserConsent = 8;
+ }
+
+ fabric_scoped struct ProviderLocation {
+ node_id providerNodeID = 1;
+ endpoint_no endpoint = 2;
+ fabric_idx fabricIndex = 254;
+ }
+
+ info event StateTransition = 0 {
+ UpdateStateEnum previousState = 0;
+ UpdateStateEnum newState = 1;
+ ChangeReasonEnum reason = 2;
+ nullable int32u targetSoftwareVersion = 3;
+ }
+
+ critical event VersionApplied = 1 {
+ int32u softwareVersion = 0;
+ int16u productID = 1;
+ }
+
+ info event DownloadError = 2 {
+ int32u softwareVersion = 0;
+ int64u bytesDownloaded = 1;
+ nullable int8u progressPercent = 2;
+ nullable int64s platformCode = 3;
+ }
+
+ attribute access(write: administer) ProviderLocation defaultOTAProviders[] = 0;
+ readonly attribute boolean updatePossible = 1;
+ readonly attribute UpdateStateEnum updateState = 2;
+ readonly attribute nullable int8u updateStateProgress = 3;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct AnnounceOTAProviderRequest {
+ node_id providerNodeID = 0;
+ vendor_id vendorID = 1;
+ AnnouncementReasonEnum announcementReason = 2;
+ optional octet_string<512> metadataForNode = 3;
+ endpoint_no endpoint = 4;
+ }
+
+ /** Announce the presence of an OTA Provider */
+ command AnnounceOTAProvider(AnnounceOTAProviderRequest): DefaultSuccess = 0;
+}
+
+/** This cluster is used to manage global aspects of the Commissioning flow. */
+cluster GeneralCommissioning = 48 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum CommissioningErrorEnum : enum8 {
+ kOK = 0;
+ kValueOutsideRange = 1;
+ kInvalidAuthentication = 2;
+ kNoFailSafe = 3;
+ kBusyWithOtherAdmin = 4;
+ kRequiredTCNotAccepted = 5;
+ kTCAcknowledgementsNotReceived = 6;
+ kTCMinVersionNotMet = 7;
+ }
+
+ enum RegulatoryLocationTypeEnum : enum8 {
+ kIndoor = 0;
+ kOutdoor = 1;
+ kIndoorOutdoor = 2;
+ }
+
+ bitmap Feature : bitmap32 {
+ kTermsAndConditions = 0x1;
+ }
+
+ struct BasicCommissioningInfo {
+ int16u failSafeExpiryLengthSeconds = 0;
+ int16u maxCumulativeFailsafeSeconds = 1;
+ }
+
+ attribute access(write: administer) int64u breadcrumb = 0;
+ readonly attribute BasicCommissioningInfo basicCommissioningInfo = 1;
+ readonly attribute RegulatoryLocationTypeEnum regulatoryConfig = 2;
+ readonly attribute RegulatoryLocationTypeEnum locationCapability = 3;
+ readonly attribute boolean supportsConcurrentConnection = 4;
+ provisional readonly attribute access(read: administer) optional int16u TCAcceptedVersion = 5;
+ provisional readonly attribute access(read: administer) optional int16u TCMinRequiredVersion = 6;
+ provisional readonly attribute access(read: administer) optional bitmap16 TCAcknowledgements = 7;
+ provisional readonly attribute access(read: administer) optional boolean TCAcknowledgementsRequired = 8;
+ provisional readonly attribute access(read: administer) optional int32u TCUpdateDeadline = 9;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct ArmFailSafeRequest {
+ int16u expiryLengthSeconds = 0;
+ int64u breadcrumb = 1;
+ }
+
+ response struct ArmFailSafeResponse = 1 {
+ CommissioningErrorEnum errorCode = 0;
+ char_string<128> debugText = 1;
+ }
+
+ request struct SetRegulatoryConfigRequest {
+ RegulatoryLocationTypeEnum newRegulatoryConfig = 0;
+ char_string<2> countryCode = 1;
+ int64u breadcrumb = 2;
+ }
+
+ response struct SetRegulatoryConfigResponse = 3 {
+ CommissioningErrorEnum errorCode = 0;
+ char_string debugText = 1;
+ }
+
+ response struct CommissioningCompleteResponse = 5 {
+ CommissioningErrorEnum errorCode = 0;
+ char_string debugText = 1;
+ }
+
+ request struct SetTCAcknowledgementsRequest {
+ int16u TCVersion = 0;
+ bitmap16 TCUserResponse = 1;
+ }
+
+ response struct SetTCAcknowledgementsResponse = 7 {
+ CommissioningErrorEnum errorCode = 0;
+ }
+
+ /** Arm the persistent fail-safe timer with an expiry time of now + ExpiryLengthSeconds using device clock */
+ command access(invoke: administer) ArmFailSafe(ArmFailSafeRequest): ArmFailSafeResponse = 0;
+ /** Set the regulatory configuration to be used during commissioning */
+ command access(invoke: administer) SetRegulatoryConfig(SetRegulatoryConfigRequest): SetRegulatoryConfigResponse = 2;
+ /** Signals the Server that the Client has successfully completed all steps of Commissioning/Recofiguration needed during fail-safe period. */
+ fabric command access(invoke: administer) CommissioningComplete(): CommissioningCompleteResponse = 4;
+ /** This command sets the user acknowledgements received in the Enhanced Setup Flow Terms and Conditions into the node. */
+ command access(invoke: administer) SetTCAcknowledgements(SetTCAcknowledgementsRequest): SetTCAcknowledgementsResponse = 6;
+}
+
+/** Functionality to configure, enable, disable network credentials and access on a Matter device. */
+cluster NetworkCommissioning = 49 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum NetworkCommissioningStatusEnum : enum8 {
+ kSuccess = 0;
+ kOutOfRange = 1;
+ kBoundsExceeded = 2;
+ kNetworkIDNotFound = 3;
+ kDuplicateNetworkID = 4;
+ kNetworkNotFound = 5;
+ kRegulatoryError = 6;
+ kAuthFailure = 7;
+ kUnsupportedSecurity = 8;
+ kOtherConnectionFailure = 9;
+ kIPV6Failed = 10;
+ kIPBindFailed = 11;
+ kUnknownError = 12;
+ }
+
+ enum WiFiBandEnum : enum8 {
+ k2G4 = 0;
+ k3G65 = 1;
+ k5G = 2;
+ k6G = 3;
+ k60G = 4;
+ k1G = 5;
+ }
+
+ bitmap Feature : bitmap32 {
+ kWiFiNetworkInterface = 0x1;
+ kThreadNetworkInterface = 0x2;
+ kEthernetNetworkInterface = 0x4;
+ kPerDeviceCredentials = 0x8;
+ }
+
+ bitmap ThreadCapabilitiesBitmap : bitmap16 {
+ kIsBorderRouterCapable = 0x1;
+ kIsRouterCapable = 0x2;
+ kIsSleepyEndDeviceCapable = 0x4;
+ kIsFullThreadDevice = 0x8;
+ kIsSynchronizedSleepyEndDeviceCapable = 0x10;
+ }
+
+ bitmap WiFiSecurityBitmap : bitmap8 {
+ kUnencrypted = 0x1;
+ kWEP = 0x2;
+ kWPAPersonal = 0x4;
+ kWPA2Personal = 0x8;
+ kWPA3Personal = 0x10;
+ kWPA3MatterPDC = 0x20;
+ }
+
+ struct NetworkInfoStruct {
+ octet_string<32> networkID = 0;
+ boolean connected = 1;
+ optional nullable octet_string<20> networkIdentifier = 2;
+ optional nullable octet_string<20> clientIdentifier = 3;
+ }
+
+ struct ThreadInterfaceScanResultStruct {
+ int16u panId = 0;
+ int64u extendedPanId = 1;
+ char_string<16> networkName = 2;
+ int16u channel = 3;
+ int8u version = 4;
+ octet_string<8> extendedAddress = 5;
+ int8s rssi = 6;
+ int8u lqi = 7;
+ }
+
+ struct WiFiInterfaceScanResultStruct {
+ WiFiSecurityBitmap security = 0;
+ octet_string<32> ssid = 1;
+ octet_string<6> bssid = 2;
+ int16u channel = 3;
+ WiFiBandEnum wiFiBand = 4;
+ int8s rssi = 5;
+ }
+
+ readonly attribute access(read: administer) int8u maxNetworks = 0;
+ readonly attribute access(read: administer) NetworkInfoStruct networks[] = 1;
+ readonly attribute optional int8u scanMaxTimeSeconds = 2;
+ readonly attribute optional int8u connectMaxTimeSeconds = 3;
+ attribute access(write: administer) boolean interfaceEnabled = 4;
+ readonly attribute access(read: administer) nullable NetworkCommissioningStatusEnum lastNetworkingStatus = 5;
+ readonly attribute access(read: administer) nullable octet_string<32> lastNetworkID = 6;
+ readonly attribute access(read: administer) nullable int32s lastConnectErrorValue = 7;
+ provisional readonly attribute optional WiFiBandEnum supportedWiFiBands[] = 8;
+ provisional readonly attribute optional ThreadCapabilitiesBitmap supportedThreadFeatures = 9;
+ provisional readonly attribute optional int16u threadVersion = 10;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct ScanNetworksRequest {
+ optional nullable octet_string<32> ssid = 0;
+ optional int64u breadcrumb = 1;
+ }
+
+ response struct ScanNetworksResponse = 1 {
+ NetworkCommissioningStatusEnum networkingStatus = 0;
+ optional char_string debugText = 1;
+ optional WiFiInterfaceScanResultStruct wiFiScanResults[] = 2;
+ optional ThreadInterfaceScanResultStruct threadScanResults[] = 3;
+ }
+
+ request struct AddOrUpdateWiFiNetworkRequest {
+ octet_string<32> ssid = 0;
+ octet_string<64> credentials = 1;
+ optional int64u breadcrumb = 2;
+ optional octet_string<140> networkIdentity = 3;
+ optional octet_string<20> clientIdentifier = 4;
+ optional octet_string<32> possessionNonce = 5;
+ }
+
+ request struct AddOrUpdateThreadNetworkRequest {
+ octet_string<254> operationalDataset = 0;
+ optional int64u breadcrumb = 1;
+ }
+
+ request struct RemoveNetworkRequest {
+ octet_string<32> networkID = 0;
+ optional int64u breadcrumb = 1;
+ }
+
+ response struct NetworkConfigResponse = 5 {
+ NetworkCommissioningStatusEnum networkingStatus = 0;
+ optional char_string<512> debugText = 1;
+ optional int8u networkIndex = 2;
+ optional octet_string<140> clientIdentity = 3;
+ optional octet_string<64> possessionSignature = 4;
+ }
+
+ request struct ConnectNetworkRequest {
+ octet_string<32> networkID = 0;
+ optional int64u breadcrumb = 1;
+ }
+
+ response struct ConnectNetworkResponse = 7 {
+ NetworkCommissioningStatusEnum networkingStatus = 0;
+ optional char_string debugText = 1;
+ nullable int32s errorValue = 2;
+ }
+
+ request struct ReorderNetworkRequest {
+ octet_string<32> networkID = 0;
+ int8u networkIndex = 1;
+ optional int64u breadcrumb = 2;
+ }
+
+ request struct QueryIdentityRequest {
+ octet_string<20> keyIdentifier = 0;
+ optional octet_string<32> possessionNonce = 1;
+ }
+
+ response struct QueryIdentityResponse = 10 {
+ octet_string<140> identity = 0;
+ optional octet_string<64> possessionSignature = 1;
+ }
+
+ /** Detemine the set of networks the device sees as available. */
+ command access(invoke: administer) ScanNetworks(ScanNetworksRequest): ScanNetworksResponse = 0;
+ /** Add or update the credentials for a given Wi-Fi network. */
+ command access(invoke: administer) AddOrUpdateWiFiNetwork(AddOrUpdateWiFiNetworkRequest): NetworkConfigResponse = 2;
+ /** Add or update the credentials for a given Thread network. */
+ command access(invoke: administer) AddOrUpdateThreadNetwork(AddOrUpdateThreadNetworkRequest): NetworkConfigResponse = 3;
+ /** Remove the definition of a given network (including its credentials). */
+ command access(invoke: administer) RemoveNetwork(RemoveNetworkRequest): NetworkConfigResponse = 4;
+ /** Connect to the specified network, using previously-defined credentials. */
+ command access(invoke: administer) ConnectNetwork(ConnectNetworkRequest): ConnectNetworkResponse = 6;
+ /** Modify the order in which networks will be presented in the Networks attribute. */
+ command access(invoke: administer) ReorderNetwork(ReorderNetworkRequest): NetworkConfigResponse = 8;
+ /** Retrieve details about and optionally proof of possession of a network client identity. */
+ command access(invoke: administer) QueryIdentity(QueryIdentityRequest): QueryIdentityResponse = 9;
+}
+
+/** The cluster provides commands for retrieving unstructured diagnostic logs from a Node that may be used to aid in diagnostics. */
+cluster DiagnosticLogs = 50 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum IntentEnum : enum8 {
+ kEndUserSupport = 0;
+ kNetworkDiag = 1;
+ kCrashLogs = 2;
+ }
+
+ enum StatusEnum : enum8 {
+ kSuccess = 0;
+ kExhausted = 1;
+ kNoLogs = 2;
+ kBusy = 3;
+ kDenied = 4;
+ }
+
+ enum TransferProtocolEnum : enum8 {
+ kResponsePayload = 0;
+ kBDX = 1;
+ }
+
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct RetrieveLogsRequestRequest {
+ IntentEnum intent = 0;
+ TransferProtocolEnum requestedProtocol = 1;
+ optional char_string<32> transferFileDesignator = 2;
+ }
+
+ response struct RetrieveLogsResponse = 1 {
+ StatusEnum status = 0;
+ long_octet_string logContent = 1;
+ optional epoch_us UTCTimeStamp = 2;
+ optional systime_us timeSinceBoot = 3;
+ }
+
+ /** Retrieving diagnostic logs from a Node */
+ command RetrieveLogsRequest(RetrieveLogsRequestRequest): RetrieveLogsResponse = 0;
+}
+
+/** The General Diagnostics Cluster, along with other diagnostics clusters, provide a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems. */
+cluster GeneralDiagnostics = 51 {
+ revision 2;
+
+ enum BootReasonEnum : enum8 {
+ kUnspecified = 0;
+ kPowerOnReboot = 1;
+ kBrownOutReset = 2;
+ kSoftwareWatchdogReset = 3;
+ kHardwareWatchdogReset = 4;
+ kSoftwareUpdateCompleted = 5;
+ kSoftwareReset = 6;
+ }
+
+ enum HardwareFaultEnum : enum8 {
+ kUnspecified = 0;
+ kRadio = 1;
+ kSensor = 2;
+ kResettableOverTemp = 3;
+ kNonResettableOverTemp = 4;
+ kPowerSource = 5;
+ kVisualDisplayFault = 6;
+ kAudioOutputFault = 7;
+ kUserInterfaceFault = 8;
+ kNonVolatileMemoryError = 9;
+ kTamperDetected = 10;
+ }
+
+ enum InterfaceTypeEnum : enum8 {
+ kUnspecified = 0;
+ kWiFi = 1;
+ kEthernet = 2;
+ kCellular = 3;
+ kThread = 4;
+ }
+
+ enum NetworkFaultEnum : enum8 {
+ kUnspecified = 0;
+ kHardwareFailure = 1;
+ kNetworkJammed = 2;
+ kConnectionFailed = 3;
+ }
+
+ enum RadioFaultEnum : enum8 {
+ kUnspecified = 0;
+ kWiFiFault = 1;
+ kCellularFault = 2;
+ kThreadFault = 3;
+ kNFCFault = 4;
+ kBLEFault = 5;
+ kEthernetFault = 6;
+ }
+
+ bitmap Feature : bitmap32 {
+ kDataModelTest = 0x1;
+ }
+
+ struct NetworkInterface {
+ char_string<32> name = 0;
+ boolean isOperational = 1;
+ nullable boolean offPremiseServicesReachableIPv4 = 2;
+ nullable boolean offPremiseServicesReachableIPv6 = 3;
+ octet_string<8> hardwareAddress = 4;
+ octet_string IPv4Addresses[] = 5;
+ octet_string IPv6Addresses[] = 6;
+ InterfaceTypeEnum type = 7;
+ }
+
+ critical event HardwareFaultChange = 0 {
+ HardwareFaultEnum current[] = 0;
+ HardwareFaultEnum previous[] = 1;
+ }
+
+ critical event RadioFaultChange = 1 {
+ RadioFaultEnum current[] = 0;
+ RadioFaultEnum previous[] = 1;
+ }
+
+ critical event NetworkFaultChange = 2 {
+ NetworkFaultEnum current[] = 0;
+ NetworkFaultEnum previous[] = 1;
+ }
+
+ critical event BootReason = 3 {
+ BootReasonEnum bootReason = 0;
+ }
+
+ readonly attribute NetworkInterface networkInterfaces[] = 0;
+ readonly attribute int16u rebootCount = 1;
+ readonly attribute optional int64u upTime = 2;
+ readonly attribute optional int32u totalOperationalHours = 3;
+ readonly attribute optional BootReasonEnum bootReason = 4;
+ readonly attribute optional HardwareFaultEnum activeHardwareFaults[] = 5;
+ readonly attribute optional RadioFaultEnum activeRadioFaults[] = 6;
+ readonly attribute optional NetworkFaultEnum activeNetworkFaults[] = 7;
+ readonly attribute boolean testEventTriggersEnabled = 8;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct TestEventTriggerRequest {
+ octet_string<16> enableKey = 0;
+ int64u eventTrigger = 1;
+ }
+
+ response struct TimeSnapshotResponse = 2 {
+ systime_ms systemTimeMs = 0;
+ nullable posix_ms posixTimeMs = 1;
+ }
+
+ request struct PayloadTestRequestRequest {
+ octet_string<16> enableKey = 0;
+ int8u value = 1;
+ int16u count = 2;
+ }
+
+ response struct PayloadTestResponse = 4 {
+ octet_string payload = 0;
+ }
+
+ /** Provide a means for certification tests to trigger some test-plan-specific events */
+ command access(invoke: manage) TestEventTrigger(TestEventTriggerRequest): DefaultSuccess = 0;
+ /** Take a snapshot of system time and epoch time. */
+ command TimeSnapshot(): TimeSnapshotResponse = 1;
+ /** Request a variable length payload response. */
+ command access(invoke: manage) PayloadTestRequest(PayloadTestRequestRequest): PayloadTestResponse = 3;
+}
+
+/** The Software Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems. */
+cluster SoftwareDiagnostics = 52 {
+ revision 1; // NOTE: Default/not specifically set
+
+ bitmap Feature : bitmap32 {
+ kWatermarks = 0x1;
+ }
+
+ struct ThreadMetricsStruct {
+ int64u id = 0;
+ optional char_string<8> name = 1;
+ optional int32u stackFreeCurrent = 2;
+ optional int32u stackFreeMinimum = 3;
+ optional int32u stackSize = 4;
+ }
+
+ info event SoftwareFault = 0 {
+ int64u id = 0;
+ optional char_string name = 1;
+ optional octet_string faultRecording = 2;
+ }
+
+ readonly attribute optional ThreadMetricsStruct threadMetrics[] = 0;
+ readonly attribute optional int64u currentHeapFree = 1;
+ readonly attribute optional int64u currentHeapUsed = 2;
+ readonly attribute optional int64u currentHeapHighWatermark = 3;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ /** Reception of this command SHALL reset the values: The StackFreeMinimum field of the ThreadMetrics attribute, CurrentHeapHighWaterMark attribute. */
+ command access(invoke: manage) ResetWatermarks(): DefaultSuccess = 0;
+}
+
+/** The Thread Network Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems */
+cluster ThreadNetworkDiagnostics = 53 {
+ revision 2;
+
+ enum ConnectionStatusEnum : enum8 {
+ kConnected = 0;
+ kNotConnected = 1;
+ }
+
+ enum NetworkFaultEnum : enum8 {
+ kUnspecified = 0;
+ kLinkDown = 1;
+ kHardwareFailure = 2;
+ kNetworkJammed = 3;
+ }
+
+ enum RoutingRoleEnum : enum8 {
+ kUnspecified = 0;
+ kUnassigned = 1;
+ kSleepyEndDevice = 2;
+ kEndDevice = 3;
+ kREED = 4;
+ kRouter = 5;
+ kLeader = 6;
+ }
+
+ bitmap Feature : bitmap32 {
+ kPacketCounts = 0x1;
+ kErrorCounts = 0x2;
+ kMLECounts = 0x4;
+ kMACCounts = 0x8;
+ }
+
+ struct NeighborTableStruct {
+ int64u extAddress = 0;
+ int32u age = 1;
+ int16u rloc16 = 2;
+ int32u linkFrameCounter = 3;
+ int32u mleFrameCounter = 4;
+ int8u lqi = 5;
+ nullable int8s averageRssi = 6;
+ nullable int8s lastRssi = 7;
+ int8u frameErrorRate = 8;
+ int8u messageErrorRate = 9;
+ boolean rxOnWhenIdle = 10;
+ boolean fullThreadDevice = 11;
+ boolean fullNetworkData = 12;
+ boolean isChild = 13;
+ }
+
+ struct OperationalDatasetComponents {
+ boolean activeTimestampPresent = 0;
+ boolean pendingTimestampPresent = 1;
+ boolean masterKeyPresent = 2;
+ boolean networkNamePresent = 3;
+ boolean extendedPanIdPresent = 4;
+ boolean meshLocalPrefixPresent = 5;
+ boolean delayPresent = 6;
+ boolean panIdPresent = 7;
+ boolean channelPresent = 8;
+ boolean pskcPresent = 9;
+ boolean securityPolicyPresent = 10;
+ boolean channelMaskPresent = 11;
+ }
+
+ struct RouteTableStruct {
+ int64u extAddress = 0;
+ int16u rloc16 = 1;
+ int8u routerId = 2;
+ int8u nextHop = 3;
+ int8u pathCost = 4;
+ int8u LQIIn = 5;
+ int8u LQIOut = 6;
+ int8u age = 7;
+ boolean allocated = 8;
+ boolean linkEstablished = 9;
+ }
+
+ struct SecurityPolicy {
+ int16u rotationTime = 0;
+ int16u flags = 1;
+ }
+
+ info event ConnectionStatus = 0 {
+ ConnectionStatusEnum connectionStatus = 0;
+ }
+
+ info event NetworkFaultChange = 1 {
+ NetworkFaultEnum current[] = 0;
+ NetworkFaultEnum previous[] = 1;
+ }
+
+ readonly attribute nullable int16u channel = 0;
+ readonly attribute nullable RoutingRoleEnum routingRole = 1;
+ readonly attribute nullable char_string<16> networkName = 2;
+ readonly attribute nullable int16u panId = 3;
+ readonly attribute nullable int64u extendedPanId = 4;
+ readonly attribute nullable octet_string<17> meshLocalPrefix = 5;
+ readonly attribute optional int64u overrunCount = 6;
+ readonly attribute NeighborTableStruct neighborTable[] = 7;
+ readonly attribute RouteTableStruct routeTable[] = 8;
+ readonly attribute nullable int32u partitionId = 9;
+ readonly attribute nullable int16u weighting = 10;
+ readonly attribute nullable int16u dataVersion = 11;
+ readonly attribute nullable int16u stableDataVersion = 12;
+ readonly attribute nullable int8u leaderRouterId = 13;
+ readonly attribute optional int16u detachedRoleCount = 14;
+ readonly attribute optional int16u childRoleCount = 15;
+ readonly attribute optional int16u routerRoleCount = 16;
+ readonly attribute optional int16u leaderRoleCount = 17;
+ readonly attribute optional int16u attachAttemptCount = 18;
+ readonly attribute optional int16u partitionIdChangeCount = 19;
+ readonly attribute optional int16u betterPartitionAttachAttemptCount = 20;
+ readonly attribute optional int16u parentChangeCount = 21;
+ readonly attribute optional int32u txTotalCount = 22;
+ readonly attribute optional int32u txUnicastCount = 23;
+ readonly attribute optional int32u txBroadcastCount = 24;
+ readonly attribute optional int32u txAckRequestedCount = 25;
+ readonly attribute optional int32u txAckedCount = 26;
+ readonly attribute optional int32u txNoAckRequestedCount = 27;
+ readonly attribute optional int32u txDataCount = 28;
+ readonly attribute optional int32u txDataPollCount = 29;
+ readonly attribute optional int32u txBeaconCount = 30;
+ readonly attribute optional int32u txBeaconRequestCount = 31;
+ readonly attribute optional int32u txOtherCount = 32;
+ readonly attribute optional int32u txRetryCount = 33;
+ readonly attribute optional int32u txDirectMaxRetryExpiryCount = 34;
+ readonly attribute optional int32u txIndirectMaxRetryExpiryCount = 35;
+ readonly attribute optional int32u txErrCcaCount = 36;
+ readonly attribute optional int32u txErrAbortCount = 37;
+ readonly attribute optional int32u txErrBusyChannelCount = 38;
+ readonly attribute optional int32u rxTotalCount = 39;
+ readonly attribute optional int32u rxUnicastCount = 40;
+ readonly attribute optional int32u rxBroadcastCount = 41;
+ readonly attribute optional int32u rxDataCount = 42;
+ readonly attribute optional int32u rxDataPollCount = 43;
+ readonly attribute optional int32u rxBeaconCount = 44;
+ readonly attribute optional int32u rxBeaconRequestCount = 45;
+ readonly attribute optional int32u rxOtherCount = 46;
+ readonly attribute optional int32u rxAddressFilteredCount = 47;
+ readonly attribute optional int32u rxDestAddrFilteredCount = 48;
+ readonly attribute optional int32u rxDuplicatedCount = 49;
+ readonly attribute optional int32u rxErrNoFrameCount = 50;
+ readonly attribute optional int32u rxErrUnknownNeighborCount = 51;
+ readonly attribute optional int32u rxErrInvalidSrcAddrCount = 52;
+ readonly attribute optional int32u rxErrSecCount = 53;
+ readonly attribute optional int32u rxErrFcsCount = 54;
+ readonly attribute optional int32u rxErrOtherCount = 55;
+ readonly attribute optional nullable int64u activeTimestamp = 56;
+ readonly attribute optional nullable int64u pendingTimestamp = 57;
+ readonly attribute optional nullable int32u delay = 58;
+ readonly attribute nullable SecurityPolicy securityPolicy = 59;
+ readonly attribute nullable octet_string<4> channelPage0Mask = 60;
+ readonly attribute nullable OperationalDatasetComponents operationalDatasetComponents = 61;
+ readonly attribute NetworkFaultEnum activeNetworkFaultsList[] = 62;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ /** Reception of this command SHALL reset the OverrunCount attributes to 0 */
+ command access(invoke: manage) ResetCounts(): DefaultSuccess = 0;
+}
+
+/** The Wi-Fi Network Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems. */
+cluster WiFiNetworkDiagnostics = 54 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum AssociationFailureCauseEnum : enum8 {
+ kUnknown = 0;
+ kAssociationFailed = 1;
+ kAuthenticationFailed = 2;
+ kSsidNotFound = 3;
+ }
+
+ enum ConnectionStatusEnum : enum8 {
+ kConnected = 0;
+ kNotConnected = 1;
+ }
+
+ enum SecurityTypeEnum : enum8 {
+ kUnspecified = 0;
+ kNone = 1;
+ kWEP = 2;
+ kWPA = 3;
+ kWPA2 = 4;
+ kWPA3 = 5;
+ }
+
+ enum WiFiVersionEnum : enum8 {
+ kA = 0;
+ kB = 1;
+ kG = 2;
+ kN = 3;
+ kAc = 4;
+ kAx = 5;
+ kAh = 6;
+ }
+
+ bitmap Feature : bitmap32 {
+ kPacketCounts = 0x1;
+ kErrorCounts = 0x2;
+ }
+
+ info event Disconnection = 0 {
+ int16u reasonCode = 0;
+ }
+
+ info event AssociationFailure = 1 {
+ AssociationFailureCauseEnum associationFailureCause = 0;
+ int16u status = 1;
+ }
+
+ info event ConnectionStatus = 2 {
+ ConnectionStatusEnum connectionStatus = 0;
+ }
+
+ readonly attribute nullable octet_string<6> bssid = 0;
+ readonly attribute nullable SecurityTypeEnum securityType = 1;
+ readonly attribute nullable WiFiVersionEnum wiFiVersion = 2;
+ readonly attribute nullable int16u channelNumber = 3;
+ readonly attribute nullable int8s rssi = 4;
+ readonly attribute optional nullable int32u beaconLostCount = 5;
+ readonly attribute optional nullable int32u beaconRxCount = 6;
+ readonly attribute optional nullable int32u packetMulticastRxCount = 7;
+ readonly attribute optional nullable int32u packetMulticastTxCount = 8;
+ readonly attribute optional nullable int32u packetUnicastRxCount = 9;
+ readonly attribute optional nullable int32u packetUnicastTxCount = 10;
+ readonly attribute optional nullable int64u currentMaxRate = 11;
+ readonly attribute optional nullable int64u overrunCount = 12;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ /** Reception of this command SHALL reset the Breacon and Packet related count attributes to 0 */
+ command ResetCounts(): DefaultSuccess = 0;
+}
+
+/** The Ethernet Network Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems. */
+cluster EthernetNetworkDiagnostics = 55 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum PHYRateEnum : enum8 {
+ kRate10M = 0;
+ kRate100M = 1;
+ kRate1G = 2;
+ kRate25G = 3;
+ kRate5G = 4;
+ kRate10G = 5;
+ kRate40G = 6;
+ kRate100G = 7;
+ kRate200G = 8;
+ kRate400G = 9;
+ }
+
+ bitmap Feature : bitmap32 {
+ kPacketCounts = 0x1;
+ kErrorCounts = 0x2;
+ }
+
+ readonly attribute optional nullable PHYRateEnum PHYRate = 0;
+ readonly attribute optional nullable boolean fullDuplex = 1;
+ readonly attribute optional int64u packetRxCount = 2;
+ readonly attribute optional int64u packetTxCount = 3;
+ readonly attribute optional int64u txErrCount = 4;
+ readonly attribute optional int64u collisionCount = 5;
+ readonly attribute optional int64u overrunCount = 6;
+ readonly attribute optional nullable boolean carrierDetect = 7;
+ readonly attribute optional int64u timeSinceReset = 8;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ /** Reception of this command SHALL reset the attributes: PacketRxCount, PacketTxCount, TxErrCount, CollisionCount, OverrunCount to 0 */
+ command access(invoke: manage) ResetCounts(): DefaultSuccess = 0;
+}
+
+/** This cluster exposes interactions with a switch device, for the purpose of using those interactions by other devices.
+Two types of switch devices are supported: latching switch (e.g. rocker switch) and momentary switch (e.g. push button), distinguished with their feature flags.
+Interactions with the switch device are exposed as attributes (for the latching switch) and as events (for both types of switches). An interested party MAY subscribe to these attributes/events and thus be informed of the interactions, and can perform actions based on this, for example by sending commands to perform an action such as controlling a light or a window shade. */
+cluster Switch = 59 {
+ revision 2;
+
+ bitmap Feature : bitmap32 {
+ kLatchingSwitch = 0x1;
+ kMomentarySwitch = 0x2;
+ kMomentarySwitchRelease = 0x4;
+ kMomentarySwitchLongPress = 0x8;
+ kMomentarySwitchMultiPress = 0x10;
+ kActionSwitch = 0x20;
+ }
+
+ info event SwitchLatched = 0 {
+ int8u newPosition = 0;
+ }
+
+ info event InitialPress = 1 {
+ int8u newPosition = 0;
+ }
+
+ info event LongPress = 2 {
+ int8u newPosition = 0;
+ }
+
+ info event ShortRelease = 3 {
+ int8u previousPosition = 0;
+ }
+
+ info event LongRelease = 4 {
+ int8u previousPosition = 0;
+ }
+
+ info event MultiPressOngoing = 5 {
+ int8u newPosition = 0;
+ int8u currentNumberOfPressesCounted = 1;
+ }
+
+ info event MultiPressComplete = 6 {
+ int8u previousPosition = 0;
+ int8u totalNumberOfPressesCounted = 1;
+ }
+
+ readonly attribute int8u numberOfPositions = 0;
+ readonly attribute int8u currentPosition = 1;
+ readonly attribute optional int8u multiPressMax = 2;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+}
+
+/** Commands to trigger a Node to allow a new Administrator to commission it. */
+cluster AdministratorCommissioning = 60 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum CommissioningWindowStatusEnum : enum8 {
+ kWindowNotOpen = 0;
+ kEnhancedWindowOpen = 1;
+ kBasicWindowOpen = 2;
+ }
+
+ enum StatusCode : enum8 {
+ kBusy = 2;
+ kPAKEParameterError = 3;
+ kWindowNotOpen = 4;
+ }
+
+ bitmap Feature : bitmap32 {
+ kBasic = 0x1;
+ }
+
+ readonly attribute CommissioningWindowStatusEnum windowStatus = 0;
+ readonly attribute nullable fabric_idx adminFabricIndex = 1;
+ readonly attribute nullable vendor_id adminVendorId = 2;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct OpenCommissioningWindowRequest {
+ int16u commissioningTimeout = 0;
+ octet_string PAKEPasscodeVerifier = 1;
+ int16u discriminator = 2;
+ int32u iterations = 3;
+ octet_string<32> salt = 4;
+ }
+
+ request struct OpenBasicCommissioningWindowRequest {
+ int16u commissioningTimeout = 0;
+ }
+
+ /** This command is used by a current Administrator to instruct a Node to go into commissioning mode using enhanced commissioning method. */
+ timed command access(invoke: administer) OpenCommissioningWindow(OpenCommissioningWindowRequest): DefaultSuccess = 0;
+ /** This command is used by a current Administrator to instruct a Node to go into commissioning mode using basic commissioning method, if the node supports it. */
+ timed command access(invoke: administer) OpenBasicCommissioningWindow(OpenBasicCommissioningWindowRequest): DefaultSuccess = 1;
+ /** This command is used by a current Administrator to instruct a Node to revoke any active Open Commissioning Window or Open Basic Commissioning Window command. */
+ timed command access(invoke: administer) RevokeCommissioning(): DefaultSuccess = 2;
+}
+
+/** This cluster is used to add or remove Operational Credentials on a Commissionee or Node, as well as manage the associated Fabrics. */
+cluster OperationalCredentials = 62 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum CertificateChainTypeEnum : enum8 {
+ kDACCertificate = 1;
+ kPAICertificate = 2;
+ }
+
+ enum NodeOperationalCertStatusEnum : enum8 {
+ kOK = 0;
+ kInvalidPublicKey = 1;
+ kInvalidNodeOpId = 2;
+ kInvalidNOC = 3;
+ kMissingCsr = 4;
+ kTableFull = 5;
+ kInvalidAdminSubject = 6;
+ kFabricConflict = 9;
+ kLabelConflict = 10;
+ kInvalidFabricIndex = 11;
+ }
+
+ fabric_scoped struct FabricDescriptorStruct {
+ octet_string<65> rootPublicKey = 1;
+ vendor_id vendorID = 2;
+ fabric_id fabricID = 3;
+ node_id nodeID = 4;
+ char_string<32> label = 5;
+ fabric_idx fabricIndex = 254;
+ }
+
+ fabric_scoped struct NOCStruct {
+ fabric_sensitive octet_string noc = 1;
+ nullable fabric_sensitive octet_string icac = 2;
+ fabric_idx fabricIndex = 254;
+ }
+
+ readonly attribute access(read: administer) NOCStruct NOCs[] = 0;
+ readonly attribute FabricDescriptorStruct fabrics[] = 1;
+ readonly attribute int8u supportedFabrics = 2;
+ readonly attribute int8u commissionedFabrics = 3;
+ readonly attribute octet_string trustedRootCertificates[] = 4;
+ readonly attribute int8u currentFabricIndex = 5;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct AttestationRequestRequest {
+ octet_string<32> attestationNonce = 0;
+ }
+
+ response struct AttestationResponse = 1 {
+ octet_string<900> attestationElements = 0;
+ octet_string<64> attestationSignature = 1;
+ }
+
+ request struct CertificateChainRequestRequest {
+ CertificateChainTypeEnum certificateType = 0;
+ }
+
+ response struct CertificateChainResponse = 3 {
+ octet_string<600> certificate = 0;
+ }
+
+ request struct CSRRequestRequest {
+ octet_string<32> CSRNonce = 0;
+ optional boolean isForUpdateNOC = 1;
+ }
+
+ response struct CSRResponse = 5 {
+ octet_string NOCSRElements = 0;
+ octet_string attestationSignature = 1;
+ }
+
+ request struct AddNOCRequest {
+ octet_string<400> NOCValue = 0;
+ optional octet_string<400> ICACValue = 1;
+ octet_string<16> IPKValue = 2;
+ int64u caseAdminSubject = 3;
+ vendor_id adminVendorId = 4;
+ }
+
+ request struct UpdateNOCRequest {
+ octet_string NOCValue = 0;
+ optional octet_string ICACValue = 1;
+ }
+
+ response struct NOCResponse = 8 {
+ NodeOperationalCertStatusEnum statusCode = 0;
+ optional fabric_idx fabricIndex = 1;
+ optional char_string<128> debugText = 2;
+ }
+
+ request struct UpdateFabricLabelRequest {
+ char_string<32> label = 0;
+ }
+
+ request struct RemoveFabricRequest {
+ fabric_idx fabricIndex = 0;
+ }
+
+ request struct AddTrustedRootCertificateRequest {
+ octet_string rootCACertificate = 0;
+ }
+
+ /** Sender is requesting attestation information from the receiver. */
+ command access(invoke: administer) AttestationRequest(AttestationRequestRequest): AttestationResponse = 0;
+ /** Sender is requesting a device attestation certificate from the receiver. */
+ command access(invoke: administer) CertificateChainRequest(CertificateChainRequestRequest): CertificateChainResponse = 2;
+ /** Sender is requesting a certificate signing request (CSR) from the receiver. */
+ command access(invoke: administer) CSRRequest(CSRRequestRequest): CSRResponse = 4;
+ /** Sender is requesting to add the new node operational certificates. */
+ command access(invoke: administer) AddNOC(AddNOCRequest): NOCResponse = 6;
+ /** Sender is requesting to update the node operational certificates. */
+ fabric command access(invoke: administer) UpdateNOC(UpdateNOCRequest): NOCResponse = 7;
+ /** This command SHALL be used by an Administrative Node to set the user-visible Label field for a given Fabric, as reflected by entries in the Fabrics attribute. */
+ fabric command access(invoke: administer) UpdateFabricLabel(UpdateFabricLabelRequest): NOCResponse = 9;
+ /** This command is used by Administrative Nodes to remove a given fabric index and delete all associated fabric-scoped data. */
+ command access(invoke: administer) RemoveFabric(RemoveFabricRequest): NOCResponse = 10;
+ /** This command SHALL add a Trusted Root CA Certificate, provided as its CHIP Certificate representation. */
+ command access(invoke: administer) AddTrustedRootCertificate(AddTrustedRootCertificateRequest): DefaultSuccess = 11;
+}
+
+/** The Group Key Management Cluster is the mechanism by which group keys are managed. */
+cluster GroupKeyManagement = 63 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum GroupKeySecurityPolicyEnum : enum8 {
+ kTrustFirst = 0;
+ kCacheAndSync = 1;
+ }
+
+ bitmap Feature : bitmap32 {
+ kCacheAndSync = 0x1;
+ }
+
+ fabric_scoped struct GroupInfoMapStruct {
+ group_id groupId = 1;
+ endpoint_no endpoints[] = 2;
+ optional char_string<16> groupName = 3;
+ fabric_idx fabricIndex = 254;
+ }
+
+ fabric_scoped struct GroupKeyMapStruct {
+ group_id groupId = 1;
+ int16u groupKeySetID = 2;
+ fabric_idx fabricIndex = 254;
+ }
+
+ struct GroupKeySetStruct {
+ int16u groupKeySetID = 0;
+ GroupKeySecurityPolicyEnum groupKeySecurityPolicy = 1;
+ nullable octet_string<16> epochKey0 = 2;
+ nullable epoch_us epochStartTime0 = 3;
+ nullable octet_string<16> epochKey1 = 4;
+ nullable epoch_us epochStartTime1 = 5;
+ nullable octet_string<16> epochKey2 = 6;
+ nullable epoch_us epochStartTime2 = 7;
+ }
+
+ attribute access(write: manage) GroupKeyMapStruct groupKeyMap[] = 0;
+ readonly attribute GroupInfoMapStruct groupTable[] = 1;
+ readonly attribute int16u maxGroupsPerFabric = 2;
+ readonly attribute int16u maxGroupKeysPerFabric = 3;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct KeySetWriteRequest {
+ GroupKeySetStruct groupKeySet = 0;
+ }
+
+ request struct KeySetReadRequest {
+ int16u groupKeySetID = 0;
+ }
+
+ response struct KeySetReadResponse = 2 {
+ GroupKeySetStruct groupKeySet = 0;
+ }
+
+ request struct KeySetRemoveRequest {
+ int16u groupKeySetID = 0;
+ }
+
+ response struct KeySetReadAllIndicesResponse = 5 {
+ int16u groupKeySetIDs[] = 0;
+ }
+
+ /** Write a new set of keys for the given key set id. */
+ fabric command access(invoke: administer) KeySetWrite(KeySetWriteRequest): DefaultSuccess = 0;
+ /** Read the keys for a given key set id. */
+ fabric command access(invoke: administer) KeySetRead(KeySetReadRequest): KeySetReadResponse = 1;
+ /** Revoke a Root Key from a Group */
+ fabric command access(invoke: administer) KeySetRemove(KeySetRemoveRequest): DefaultSuccess = 3;
+ /** Return the list of Group Key Sets associated with the accessing fabric */
+ fabric command access(invoke: administer) KeySetReadAllIndices(): KeySetReadAllIndicesResponse = 4;
+}
+
+/** The Fixed Label Cluster provides a feature for the device to tag an endpoint with zero or more read only
+labels. */
+cluster FixedLabel = 64 {
+ revision 1; // NOTE: Default/not specifically set
+
+ struct LabelStruct {
+ char_string<16> label = 0;
+ char_string<16> value = 1;
+ }
+
+ readonly attribute LabelStruct labelList[] = 0;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+}
+
+/** The User Label Cluster provides a feature to tag an endpoint with zero or more labels. */
+cluster UserLabel = 65 {
+ revision 1; // NOTE: Default/not specifically set
+
+ struct LabelStruct {
+ char_string<16> label = 0;
+ char_string<16> value = 1;
+ }
+
+ attribute access(write: manage) LabelStruct labelList[] = 0;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+}
+
+/** Attributes and commands for scene configuration and manipulation. */
+provisional cluster ScenesManagement = 98 {
+ revision 1;
+
+ bitmap CopyModeBitmap : bitmap8 {
+ kCopyAllScenes = 0x1;
+ }
+
+ bitmap Feature : bitmap32 {
+ kSceneNames = 0x1;
+ }
+
+ struct AttributeValuePairStruct {
+ attrib_id attributeID = 0;
+ optional int8u valueUnsigned8 = 1;
+ optional int8s valueSigned8 = 2;
+ optional int16u valueUnsigned16 = 3;
+ optional int16s valueSigned16 = 4;
+ optional int32u valueUnsigned32 = 5;
+ optional int32s valueSigned32 = 6;
+ optional int64u valueUnsigned64 = 7;
+ optional int64s valueSigned64 = 8;
+ }
+
+ struct ExtensionFieldSet {
+ cluster_id clusterID = 0;
+ AttributeValuePairStruct attributeValueList[] = 1;
+ }
+
+ fabric_scoped struct SceneInfoStruct {
+ int8u sceneCount = 0;
+ fabric_sensitive int8u currentScene = 1;
+ fabric_sensitive group_id currentGroup = 2;
+ fabric_sensitive boolean sceneValid = 3;
+ int8u remainingCapacity = 4;
+ fabric_idx fabricIndex = 254;
+ }
+
+ readonly attribute optional nullable node_id lastConfiguredBy = 0;
+ readonly attribute int16u sceneTableSize = 1;
+ readonly attribute SceneInfoStruct fabricSceneInfo[] = 2;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct AddSceneRequest {
+ group_id groupID = 0;
+ int8u sceneID = 1;
+ int32u transitionTime = 2;
+ char_string sceneName = 3;
+ ExtensionFieldSet extensionFieldSets[] = 4;
+ }
+
+ response struct AddSceneResponse = 0 {
+ status status = 0;
+ group_id groupID = 1;
+ int8u sceneID = 2;
+ }
+
+ request struct ViewSceneRequest {
+ group_id groupID = 0;
+ int8u sceneID = 1;
+ }
+
+ response struct ViewSceneResponse = 1 {
+ status status = 0;
+ group_id groupID = 1;
+ int8u sceneID = 2;
+ optional int32u transitionTime = 3;
+ optional char_string sceneName = 4;
+ optional ExtensionFieldSet extensionFieldSets[] = 5;
+ }
+
+ request struct RemoveSceneRequest {
+ group_id groupID = 0;
+ int8u sceneID = 1;
+ }
+
+ response struct RemoveSceneResponse = 2 {
+ status status = 0;
+ group_id groupID = 1;
+ int8u sceneID = 2;
+ }
+
+ request struct RemoveAllScenesRequest {
+ group_id groupID = 0;
+ }
+
+ response struct RemoveAllScenesResponse = 3 {
+ status status = 0;
+ group_id groupID = 1;
+ }
+
+ request struct StoreSceneRequest {
+ group_id groupID = 0;
+ int8u sceneID = 1;
+ }
+
+ response struct StoreSceneResponse = 4 {
+ status status = 0;
+ group_id groupID = 1;
+ int8u sceneID = 2;
+ }
+
+ request struct RecallSceneRequest {
+ group_id groupID = 0;
+ int8u sceneID = 1;
+ optional nullable int32u transitionTime = 2;
+ }
+
+ request struct GetSceneMembershipRequest {
+ group_id groupID = 0;
+ }
+
+ response struct GetSceneMembershipResponse = 6 {
+ status status = 0;
+ nullable int8u capacity = 1;
+ group_id groupID = 2;
+ optional int8u sceneList[] = 3;
+ }
+
+ request struct CopySceneRequest {
+ CopyModeBitmap mode = 0;
+ group_id groupIdentifierFrom = 1;
+ int8u sceneIdentifierFrom = 2;
+ group_id groupIdentifierTo = 3;
+ int8u sceneIdentifierTo = 4;
+ }
+
+ response struct CopySceneResponse = 64 {
+ status status = 0;
+ group_id groupIdentifierFrom = 1;
+ int8u sceneIdentifierFrom = 2;
+ }
+
+ /** Add a scene to the scene table. Extension field sets are supported, and are inputed as '{"ClusterID": VALUE, "AttributeValueList":[{"AttributeID": VALUE, "Value*": VALUE}]}' */
+ fabric command access(invoke: manage) AddScene(AddSceneRequest): AddSceneResponse = 0;
+ /** Retrieves the requested scene entry from its Scene table. */
+ fabric command ViewScene(ViewSceneRequest): ViewSceneResponse = 1;
+ /** Removes the requested scene entry, corresponding to the value of the GroupID field, from its Scene Table */
+ fabric command access(invoke: manage) RemoveScene(RemoveSceneRequest): RemoveSceneResponse = 2;
+ /** Remove all scenes, corresponding to the value of the GroupID field, from its Scene Table */
+ fabric command access(invoke: manage) RemoveAllScenes(RemoveAllScenesRequest): RemoveAllScenesResponse = 3;
+ /** Adds the scene entry into its Scene Table along with all extension field sets corresponding to the current state of other clusters on the same endpoint */
+ fabric command access(invoke: manage) StoreScene(StoreSceneRequest): StoreSceneResponse = 4;
+ /** Set the attributes and corresponding state for each other cluster implemented on the endpoint accordingly to the resquested scene entry in the Scene Table */
+ fabric command RecallScene(RecallSceneRequest): DefaultSuccess = 5;
+ /** Get an unused scene identifier when no commissioning tool is in the network, or for a commissioning tool to get the used scene identifiers within a certain group */
+ fabric command GetSceneMembership(GetSceneMembershipRequest): GetSceneMembershipResponse = 6;
+ /** Allows a client to efficiently copy scenes from one group/scene identifier pair to another group/scene identifier pair. */
+ fabric command access(invoke: manage) CopyScene(CopySceneRequest): CopySceneResponse = 64;
+}
+
+/** Attributes and commands for controlling the color properties of a color-capable light. */
+cluster ColorControl = 768 {
+ revision 7;
+
+ enum ColorLoopActionEnum : enum8 {
+ kDeactivate = 0;
+ kActivateFromColorLoopStartEnhancedHue = 1;
+ kActivateFromEnhancedCurrentHue = 2;
+ }
+
+ enum ColorLoopDirectionEnum : enum8 {
+ kDecrement = 0;
+ kIncrement = 1;
+ }
+
+ enum ColorModeEnum : enum8 {
+ kCurrentHueAndCurrentSaturation = 0;
+ kCurrentXAndCurrentY = 1;
+ kColorTemperatureMireds = 2;
+ }
+
+ enum DirectionEnum : enum8 {
+ kShortest = 0;
+ kLongest = 1;
+ kUp = 2;
+ kDown = 3;
+ }
+
+ enum DriftCompensationEnum : enum8 {
+ kNone = 0;
+ kOtherOrUnknown = 1;
+ kTemperatureMonitoring = 2;
+ kOpticalLuminanceMonitoringAndFeedback = 3;
+ kOpticalColorMonitoringAndFeedback = 4;
+ }
+
+ enum EnhancedColorModeEnum : enum8 {
+ kCurrentHueAndCurrentSaturation = 0;
+ kCurrentXAndCurrentY = 1;
+ kColorTemperatureMireds = 2;
+ kEnhancedCurrentHueAndCurrentSaturation = 3;
+ }
+
+ enum MoveModeEnum : enum8 {
+ kStop = 0;
+ kUp = 1;
+ kDown = 3;
+ }
+
+ enum StepModeEnum : enum8 {
+ kUp = 1;
+ kDown = 3;
+ }
+
+ bitmap ColorCapabilitiesBitmap : bitmap16 {
+ kHueSaturation = 0x1;
+ kEnhancedHue = 0x2;
+ kColorLoop = 0x4;
+ kXY = 0x8;
+ kColorTemperature = 0x10;
+ }
+
+ bitmap Feature : bitmap32 {
+ kHueAndSaturation = 0x1;
+ kEnhancedHue = 0x2;
+ kColorLoop = 0x4;
+ kXY = 0x8;
+ kColorTemperature = 0x10;
+ }
+
+ bitmap OptionsBitmap : bitmap8 {
+ kExecuteIfOff = 0x1;
+ }
+
+ bitmap UpdateFlagsBitmap : bitmap8 {
+ kUpdateAction = 0x1;
+ kUpdateDirection = 0x2;
+ kUpdateTime = 0x4;
+ kUpdateStartHue = 0x8;
+ }
+
+ readonly attribute optional int8u currentHue = 0;
+ readonly attribute optional int8u currentSaturation = 1;
+ readonly attribute optional int16u remainingTime = 2;
+ readonly attribute optional int16u currentX = 3;
+ readonly attribute optional int16u currentY = 4;
+ readonly attribute optional DriftCompensationEnum driftCompensation = 5;
+ readonly attribute optional char_string<254> compensationText = 6;
+ readonly attribute optional int16u colorTemperatureMireds = 7;
+ readonly attribute ColorModeEnum colorMode = 8;
+ attribute OptionsBitmap options = 15;
+ readonly attribute nullable int8u numberOfPrimaries = 16;
+ readonly attribute optional int16u primary1X = 17;
+ readonly attribute optional int16u primary1Y = 18;
+ readonly attribute optional nullable int8u primary1Intensity = 19;
+ readonly attribute optional int16u primary2X = 21;
+ readonly attribute optional int16u primary2Y = 22;
+ readonly attribute optional nullable int8u primary2Intensity = 23;
+ readonly attribute optional int16u primary3X = 25;
+ readonly attribute optional int16u primary3Y = 26;
+ readonly attribute optional nullable int8u primary3Intensity = 27;
+ readonly attribute optional int16u primary4X = 32;
+ readonly attribute optional int16u primary4Y = 33;
+ readonly attribute optional nullable int8u primary4Intensity = 34;
+ readonly attribute optional int16u primary5X = 36;
+ readonly attribute optional int16u primary5Y = 37;
+ readonly attribute optional nullable int8u primary5Intensity = 38;
+ readonly attribute optional int16u primary6X = 40;
+ readonly attribute optional int16u primary6Y = 41;
+ readonly attribute optional nullable int8u primary6Intensity = 42;
+ attribute access(write: manage) optional int16u whitePointX = 48;
+ attribute access(write: manage) optional int16u whitePointY = 49;
+ attribute access(write: manage) optional int16u colorPointRX = 50;
+ attribute access(write: manage) optional int16u colorPointRY = 51;
+ attribute access(write: manage) optional nullable int8u colorPointRIntensity = 52;
+ attribute access(write: manage) optional int16u colorPointGX = 54;
+ attribute access(write: manage) optional int16u colorPointGY = 55;
+ attribute access(write: manage) optional nullable int8u colorPointGIntensity = 56;
+ attribute access(write: manage) optional int16u colorPointBX = 58;
+ attribute access(write: manage) optional int16u colorPointBY = 59;
+ attribute access(write: manage) optional nullable int8u colorPointBIntensity = 60;
+ readonly attribute optional int16u enhancedCurrentHue = 16384;
+ readonly attribute EnhancedColorModeEnum enhancedColorMode = 16385;
+ readonly attribute optional int8u colorLoopActive = 16386;
+ readonly attribute optional int8u colorLoopDirection = 16387;
+ readonly attribute optional int16u colorLoopTime = 16388;
+ readonly attribute optional int16u colorLoopStartEnhancedHue = 16389;
+ readonly attribute optional int16u colorLoopStoredEnhancedHue = 16390;
+ readonly attribute ColorCapabilitiesBitmap colorCapabilities = 16394;
+ readonly attribute optional int16u colorTempPhysicalMinMireds = 16395;
+ readonly attribute optional int16u colorTempPhysicalMaxMireds = 16396;
+ readonly attribute optional int16u coupleColorTempToLevelMinMireds = 16397;
+ attribute access(write: manage) optional nullable int16u startUpColorTemperatureMireds = 16400;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct MoveToHueRequest {
+ int8u hue = 0;
+ DirectionEnum direction = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct MoveHueRequest {
+ MoveModeEnum moveMode = 0;
+ int8u rate = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct StepHueRequest {
+ StepModeEnum stepMode = 0;
+ int8u stepSize = 1;
+ int8u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct MoveToSaturationRequest {
+ int8u saturation = 0;
+ int16u transitionTime = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct MoveSaturationRequest {
+ MoveModeEnum moveMode = 0;
+ int8u rate = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct StepSaturationRequest {
+ StepModeEnum stepMode = 0;
+ int8u stepSize = 1;
+ int8u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct MoveToHueAndSaturationRequest {
+ int8u hue = 0;
+ int8u saturation = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct MoveToColorRequest {
+ int16u colorX = 0;
+ int16u colorY = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct MoveColorRequest {
+ int16s rateX = 0;
+ int16s rateY = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct StepColorRequest {
+ int16s stepX = 0;
+ int16s stepY = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct MoveToColorTemperatureRequest {
+ int16u colorTemperatureMireds = 0;
+ int16u transitionTime = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct EnhancedMoveToHueRequest {
+ int16u enhancedHue = 0;
+ DirectionEnum direction = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct EnhancedMoveHueRequest {
+ MoveModeEnum moveMode = 0;
+ int16u rate = 1;
+ OptionsBitmap optionsMask = 2;
+ OptionsBitmap optionsOverride = 3;
+ }
+
+ request struct EnhancedStepHueRequest {
+ StepModeEnum stepMode = 0;
+ int16u stepSize = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct EnhancedMoveToHueAndSaturationRequest {
+ int16u enhancedHue = 0;
+ int8u saturation = 1;
+ int16u transitionTime = 2;
+ OptionsBitmap optionsMask = 3;
+ OptionsBitmap optionsOverride = 4;
+ }
+
+ request struct ColorLoopSetRequest {
+ UpdateFlagsBitmap updateFlags = 0;
+ ColorLoopActionEnum action = 1;
+ ColorLoopDirectionEnum direction = 2;
+ int16u time = 3;
+ int16u startHue = 4;
+ OptionsBitmap optionsMask = 5;
+ OptionsBitmap optionsOverride = 6;
+ }
+
+ request struct StopMoveStepRequest {
+ OptionsBitmap optionsMask = 0;
+ OptionsBitmap optionsOverride = 1;
+ }
+
+ request struct MoveColorTemperatureRequest {
+ MoveModeEnum moveMode = 0;
+ int16u rate = 1;
+ int16u colorTemperatureMinimumMireds = 2;
+ int16u colorTemperatureMaximumMireds = 3;
+ OptionsBitmap optionsMask = 4;
+ OptionsBitmap optionsOverride = 5;
+ }
+
+ request struct StepColorTemperatureRequest {
+ StepModeEnum stepMode = 0;
+ int16u stepSize = 1;
+ int16u transitionTime = 2;
+ int16u colorTemperatureMinimumMireds = 3;
+ int16u colorTemperatureMaximumMireds = 4;
+ OptionsBitmap optionsMask = 5;
+ OptionsBitmap optionsOverride = 6;
+ }
+
+ /** Move to specified hue. */
+ command MoveToHue(MoveToHueRequest): DefaultSuccess = 0;
+ /** Move hue up or down at specified rate. */
+ command MoveHue(MoveHueRequest): DefaultSuccess = 1;
+ /** Step hue up or down by specified size at specified rate. */
+ command StepHue(StepHueRequest): DefaultSuccess = 2;
+ /** Move to specified saturation. */
+ command MoveToSaturation(MoveToSaturationRequest): DefaultSuccess = 3;
+ /** Move saturation up or down at specified rate. */
+ command MoveSaturation(MoveSaturationRequest): DefaultSuccess = 4;
+ /** Step saturation up or down by specified size at specified rate. */
+ command StepSaturation(StepSaturationRequest): DefaultSuccess = 5;
+ /** Move to hue and saturation. */
+ command MoveToHueAndSaturation(MoveToHueAndSaturationRequest): DefaultSuccess = 6;
+ /** Move to specified color. */
+ command MoveToColor(MoveToColorRequest): DefaultSuccess = 7;
+ /** Moves the color. */
+ command MoveColor(MoveColorRequest): DefaultSuccess = 8;
+ /** Steps the lighting to a specific color. */
+ command StepColor(StepColorRequest): DefaultSuccess = 9;
+ /** Move to a specific color temperature. */
+ command MoveToColorTemperature(MoveToColorTemperatureRequest): DefaultSuccess = 10;
+ /** Command description for EnhancedMoveToHue */
+ command EnhancedMoveToHue(EnhancedMoveToHueRequest): DefaultSuccess = 64;
+ /** Command description for EnhancedMoveHue */
+ command EnhancedMoveHue(EnhancedMoveHueRequest): DefaultSuccess = 65;
+ /** Command description for EnhancedStepHue */
+ command EnhancedStepHue(EnhancedStepHueRequest): DefaultSuccess = 66;
+ /** Command description for EnhancedMoveToHueAndSaturation */
+ command EnhancedMoveToHueAndSaturation(EnhancedMoveToHueAndSaturationRequest): DefaultSuccess = 67;
+ /** Command description for ColorLoopSet */
+ command ColorLoopSet(ColorLoopSetRequest): DefaultSuccess = 68;
+ /** Command description for StopMoveStep */
+ command StopMoveStep(StopMoveStepRequest): DefaultSuccess = 71;
+ /** Command description for MoveColorTemperature */
+ command MoveColorTemperature(MoveColorTemperatureRequest): DefaultSuccess = 75;
+ /** Command description for StepColorTemperature */
+ command StepColorTemperature(StepColorTemperatureRequest): DefaultSuccess = 76;
+}
+
+/** A sample showcasing an out-of-tree definition of a manufacturer specific cluster */
+cluster SampleExternalManufacturerSpecific = 4294048801 {
+ revision 1; // NOTE: Default/not specifically set
+
+ info event PingCountEvent = 0 {
+ int32u count = 1;
+ }
+
+ nosubscribe attribute boolean flipFlop = 0;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ response struct AddArgumentsResponse = 1 {
+ int8u returnValue = 0;
+ }
+
+ request struct AddArgumentsRequest {
+ int8u arg1 = 0;
+ int8u arg2 = 1;
+ }
+
+ /** Simple command without any parameters and without a response. */
+ command Ping(): DefaultSuccess = 0;
+ /** Command that takes two uint8 arguments and returns their sum. */
+ command AddArguments(AddArgumentsRequest): AddArgumentsResponse = 2;
+}
+
+endpoint 0 {
+ device type ma_rootdevice = 22, version 1;
+
+ binding cluster OtaSoftwareUpdateProvider;
+
+ server cluster Descriptor {
+ callback attribute deviceTypeList;
+ callback attribute serverList;
+ callback attribute clientList;
+ callback attribute partsList;
+ callback attribute featureMap;
+ callback attribute clusterRevision;
+ }
+
+ server cluster AccessControl {
+ emits event AccessControlEntryChanged;
+ emits event AccessControlExtensionChanged;
+ callback attribute acl;
+ callback attribute extension;
+ callback attribute subjectsPerAccessControlEntry;
+ callback attribute targetsPerAccessControlEntry;
+ callback attribute accessControlEntriesPerFabric;
+ callback attribute attributeList;
+ ram attribute featureMap default = 0;
+ callback attribute clusterRevision;
+ }
+
+ server cluster BasicInformation {
+ emits event StartUp;
+ emits event ShutDown;
+ emits event Leave;
+ callback attribute dataModelRevision;
+ callback attribute vendorName;
+ callback attribute vendorID;
+ callback attribute productName;
+ callback attribute productID;
+ persist attribute nodeLabel;
+ callback attribute location;
+ callback attribute hardwareVersion;
+ callback attribute hardwareVersionString;
+ callback attribute softwareVersion;
+ callback attribute softwareVersionString;
+ callback attribute manufacturingDate;
+ callback attribute partNumber;
+ callback attribute productURL;
+ callback attribute productLabel;
+ callback attribute serialNumber;
+ persist attribute localConfigDisabled default = 0;
+ callback attribute uniqueID;
+ callback attribute capabilityMinima;
+ callback attribute specificationVersion;
+ callback attribute maxPathsPerInvoke;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 3;
+ }
+
+ server cluster OtaSoftwareUpdateRequestor {
+ emits event StateTransition;
+ emits event VersionApplied;
+ emits event DownloadError;
+ callback attribute defaultOTAProviders;
+ ram attribute updatePossible default = 1;
+ ram attribute updateState default = 0;
+ ram attribute updateStateProgress default = 0;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+
+ handle command AnnounceOTAProvider;
+ }
+
+ server cluster GeneralCommissioning {
+ ram attribute breadcrumb default = 0x0000000000000000;
+ callback attribute basicCommissioningInfo;
+ callback attribute regulatoryConfig;
+ callback attribute locationCapability;
+ callback attribute supportsConcurrentConnection;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+
+ handle command ArmFailSafe;
+ handle command ArmFailSafeResponse;
+ handle command SetRegulatoryConfig;
+ handle command SetRegulatoryConfigResponse;
+ handle command CommissioningComplete;
+ handle command CommissioningCompleteResponse;
+ }
+
+ server cluster NetworkCommissioning {
+ ram attribute maxNetworks;
+ callback attribute networks;
+ ram attribute scanMaxTimeSeconds;
+ ram attribute connectMaxTimeSeconds;
+ ram attribute interfaceEnabled;
+ ram attribute lastNetworkingStatus;
+ ram attribute lastNetworkID;
+ ram attribute lastConnectErrorValue;
+ ram attribute featureMap default = 2;
+ ram attribute clusterRevision default = 1;
+
+ handle command ScanNetworks;
+ handle command ScanNetworksResponse;
+ handle command AddOrUpdateWiFiNetwork;
+ handle command AddOrUpdateThreadNetwork;
+ handle command RemoveNetwork;
+ handle command NetworkConfigResponse;
+ handle command ConnectNetwork;
+ handle command ConnectNetworkResponse;
+ handle command ReorderNetwork;
+ }
+
+ server cluster DiagnosticLogs {
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+
+ handle command RetrieveLogsRequest;
+ }
+
+ server cluster GeneralDiagnostics {
+ emits event HardwareFaultChange;
+ emits event RadioFaultChange;
+ emits event NetworkFaultChange;
+ emits event BootReason;
+ callback attribute networkInterfaces;
+ callback attribute rebootCount;
+ callback attribute upTime;
+ callback attribute totalOperationalHours;
+ callback attribute bootReason;
+ callback attribute activeHardwareFaults;
+ callback attribute activeRadioFaults;
+ callback attribute activeNetworkFaults;
+ callback attribute testEventTriggersEnabled default = false;
+ callback attribute featureMap;
+ callback attribute clusterRevision;
+
+ handle command TestEventTrigger;
+ handle command TimeSnapshot;
+ handle command TimeSnapshotResponse;
+ }
+
+ server cluster SoftwareDiagnostics {
+ callback attribute threadMetrics;
+ callback attribute currentHeapFree;
+ callback attribute currentHeapUsed;
+ callback attribute currentHeapHighWatermark;
+ callback attribute featureMap;
+ ram attribute clusterRevision default = 1;
+
+ handle command ResetWatermarks;
+ }
+
+ server cluster ThreadNetworkDiagnostics {
+ callback attribute channel;
+ callback attribute routingRole;
+ callback attribute networkName;
+ callback attribute panId;
+ callback attribute extendedPanId;
+ callback attribute meshLocalPrefix;
+ callback attribute overrunCount;
+ callback attribute neighborTable;
+ callback attribute routeTable;
+ callback attribute partitionId;
+ callback attribute weighting;
+ callback attribute dataVersion;
+ callback attribute stableDataVersion;
+ callback attribute leaderRouterId;
+ callback attribute detachedRoleCount;
+ callback attribute childRoleCount;
+ callback attribute routerRoleCount;
+ callback attribute leaderRoleCount;
+ callback attribute attachAttemptCount;
+ callback attribute partitionIdChangeCount;
+ callback attribute betterPartitionAttachAttemptCount;
+ callback attribute parentChangeCount;
+ callback attribute txTotalCount;
+ callback attribute txUnicastCount;
+ callback attribute txBroadcastCount;
+ callback attribute txAckRequestedCount;
+ callback attribute txAckedCount;
+ callback attribute txNoAckRequestedCount;
+ callback attribute txDataCount;
+ callback attribute txDataPollCount;
+ callback attribute txBeaconCount;
+ callback attribute txBeaconRequestCount;
+ callback attribute txOtherCount;
+ callback attribute txRetryCount;
+ callback attribute txDirectMaxRetryExpiryCount;
+ callback attribute txIndirectMaxRetryExpiryCount;
+ callback attribute txErrCcaCount;
+ callback attribute txErrAbortCount;
+ callback attribute txErrBusyChannelCount;
+ callback attribute rxTotalCount;
+ callback attribute rxUnicastCount;
+ callback attribute rxBroadcastCount;
+ callback attribute rxDataCount;
+ callback attribute rxDataPollCount;
+ callback attribute rxBeaconCount;
+ callback attribute rxBeaconRequestCount;
+ callback attribute rxOtherCount;
+ callback attribute rxAddressFilteredCount;
+ callback attribute rxDestAddrFilteredCount;
+ callback attribute rxDuplicatedCount;
+ callback attribute rxErrNoFrameCount;
+ callback attribute rxErrUnknownNeighborCount;
+ callback attribute rxErrInvalidSrcAddrCount;
+ callback attribute rxErrSecCount;
+ callback attribute rxErrFcsCount;
+ callback attribute rxErrOtherCount;
+ callback attribute activeTimestamp;
+ callback attribute pendingTimestamp;
+ callback attribute delay;
+ callback attribute securityPolicy;
+ callback attribute channelPage0Mask;
+ callback attribute operationalDatasetComponents;
+ callback attribute activeNetworkFaultsList;
+ ram attribute featureMap default = 0x000F;
+ ram attribute clusterRevision default = 2;
+
+ handle command ResetCounts;
+ }
+
+ server cluster WiFiNetworkDiagnostics {
+ emits event Disconnection;
+ emits event AssociationFailure;
+ emits event ConnectionStatus;
+ callback attribute bssid;
+ callback attribute securityType;
+ callback attribute wiFiVersion;
+ callback attribute channelNumber;
+ callback attribute rssi;
+ callback attribute beaconLostCount;
+ callback attribute beaconRxCount;
+ callback attribute packetMulticastRxCount;
+ callback attribute packetMulticastTxCount;
+ callback attribute packetUnicastRxCount;
+ callback attribute packetUnicastTxCount;
+ callback attribute currentMaxRate;
+ callback attribute overrunCount;
+ ram attribute featureMap default = 3;
+ ram attribute clusterRevision default = 1;
+
+ handle command ResetCounts;
+ }
+
+ server cluster EthernetNetworkDiagnostics {
+ callback attribute PHYRate;
+ callback attribute fullDuplex;
+ callback attribute packetRxCount;
+ callback attribute packetTxCount;
+ callback attribute txErrCount;
+ callback attribute collisionCount;
+ callback attribute overrunCount;
+ callback attribute carrierDetect;
+ callback attribute timeSinceReset;
+ ram attribute featureMap default = 3;
+ ram attribute clusterRevision default = 1;
+
+ handle command ResetCounts;
+ }
+
+ server cluster Switch {
+ emits event SwitchLatched;
+ ram attribute numberOfPositions default = 2;
+ ram attribute currentPosition;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 2;
+ }
+
+ server cluster AdministratorCommissioning {
+ callback attribute windowStatus;
+ callback attribute adminFabricIndex;
+ callback attribute adminVendorId;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+
+ handle command OpenCommissioningWindow;
+ handle command OpenBasicCommissioningWindow;
+ handle command RevokeCommissioning;
+ }
+
+ server cluster OperationalCredentials {
+ callback attribute NOCs;
+ callback attribute fabrics;
+ callback attribute supportedFabrics;
+ callback attribute commissionedFabrics;
+ callback attribute trustedRootCertificates;
+ callback attribute currentFabricIndex;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+
+ handle command AttestationRequest;
+ handle command AttestationResponse;
+ handle command CertificateChainRequest;
+ handle command CertificateChainResponse;
+ handle command CSRRequest;
+ handle command CSRResponse;
+ handle command AddNOC;
+ handle command UpdateNOC;
+ handle command NOCResponse;
+ handle command UpdateFabricLabel;
+ handle command RemoveFabric;
+ handle command AddTrustedRootCertificate;
+ }
+
+ server cluster GroupKeyManagement {
+ callback attribute groupKeyMap;
+ callback attribute groupTable;
+ callback attribute maxGroupsPerFabric;
+ callback attribute maxGroupKeysPerFabric;
+ callback attribute featureMap;
+ callback attribute clusterRevision;
+
+ handle command KeySetWrite;
+ handle command KeySetRead;
+ handle command KeySetReadResponse;
+ handle command KeySetRemove;
+ handle command KeySetReadAllIndices;
+ handle command KeySetReadAllIndicesResponse;
+ }
+
+ server cluster FixedLabel {
+ callback attribute labelList;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+ }
+
+ server cluster UserLabel {
+ callback attribute labelList;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+ }
+}
+endpoint 1 {
+ device type ma_dimmablelight = 257, version 1;
+
+
+ server cluster Identify {
+ ram attribute identifyTime default = 0x0000;
+ ram attribute identifyType default = 0x0;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 4;
+
+ handle command Identify;
+ handle command TriggerEffect;
+ }
+
+ server cluster Groups {
+ ram attribute nameSupport;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 4;
+
+ handle command AddGroup;
+ handle command AddGroupResponse;
+ handle command ViewGroup;
+ handle command ViewGroupResponse;
+ handle command GetGroupMembership;
+ handle command GetGroupMembershipResponse;
+ handle command RemoveGroup;
+ handle command RemoveGroupResponse;
+ handle command RemoveAllGroups;
+ handle command AddGroupIfIdentifying;
+ }
+
+ server cluster OnOff {
+ persist attribute onOff default = 0x00;
+ ram attribute globalSceneControl default = 0x01;
+ ram attribute onTime default = 0x0000;
+ ram attribute offWaitTime default = 0x0000;
+ persist attribute startUpOnOff default = 0xFF;
+ ram attribute featureMap default = 1;
+ ram attribute clusterRevision default = 5;
+
+ handle command Off;
+ handle command On;
+ handle command Toggle;
+ handle command OffWithEffect;
+ handle command OnWithRecallGlobalScene;
+ handle command OnWithTimedOff;
+ }
+
+ server cluster LevelControl {
+ persist attribute currentLevel default = 0xFE;
+ ram attribute remainingTime default = 0x0000;
+ ram attribute minLevel default = 0x01;
+ ram attribute maxLevel default = 0xFE;
+ ram attribute currentFrequency default = 0x0000;
+ ram attribute minFrequency default = 0x0000;
+ ram attribute maxFrequency default = 0x0000;
+ ram attribute options default = 0x00;
+ ram attribute onOffTransitionTime default = 0x0000;
+ ram attribute onLevel default = 0xFF;
+ ram attribute onTransitionTime;
+ ram attribute offTransitionTime;
+ ram attribute defaultMoveRate default = 50;
+ persist attribute startUpCurrentLevel default = 255;
+ ram attribute featureMap default = 3;
+ ram attribute clusterRevision default = 6;
+
+ handle command MoveToLevel;
+ handle command Move;
+ handle command Step;
+ handle command Stop;
+ handle command MoveToLevelWithOnOff;
+ handle command MoveWithOnOff;
+ handle command StepWithOnOff;
+ handle command StopWithOnOff;
+ }
+
+ server cluster Descriptor {
+ callback attribute deviceTypeList;
+ callback attribute serverList;
+ callback attribute clientList;
+ callback attribute partsList;
+ callback attribute featureMap;
+ callback attribute clusterRevision;
+ }
+
+ server cluster ScenesManagement {
+ ram attribute lastConfiguredBy;
+ ram attribute sceneTableSize default = 16;
+ callback attribute fabricSceneInfo;
+ callback attribute generatedCommandList;
+ callback attribute acceptedCommandList;
+ callback attribute attributeList;
+ ram attribute featureMap default = 1;
+ ram attribute clusterRevision default = 1;
+
+ handle command AddScene;
+ handle command AddSceneResponse;
+ handle command ViewScene;
+ handle command ViewSceneResponse;
+ handle command RemoveScene;
+ handle command RemoveSceneResponse;
+ handle command RemoveAllScenes;
+ handle command RemoveAllScenesResponse;
+ handle command StoreScene;
+ handle command StoreSceneResponse;
+ handle command RecallScene;
+ handle command GetSceneMembership;
+ handle command GetSceneMembershipResponse;
+ handle command CopyScene;
+ }
+
+ server cluster ColorControl {
+ persist attribute currentHue default = 0x00;
+ persist attribute currentSaturation default = 0x00;
+ ram attribute remainingTime default = 0x0000;
+ persist attribute currentX default = 0x616B;
+ persist attribute currentY default = 0x607D;
+ persist attribute colorTemperatureMireds default = 0x00FA;
+ persist attribute colorMode default = 0x01;
+ ram attribute options default = 0x00;
+ ram attribute numberOfPrimaries;
+ persist attribute enhancedCurrentHue default = 0x0000;
+ persist attribute enhancedColorMode default = 0x01;
+ persist attribute colorLoopActive default = 0x00;
+ persist attribute colorLoopDirection default = 0x00;
+ persist attribute colorLoopTime default = 0x0019;
+ ram attribute colorLoopStartEnhancedHue default = 0x2300;
+ ram attribute colorLoopStoredEnhancedHue default = 0x0000;
+ ram attribute colorCapabilities default = 0x1F;
+ ram attribute colorTempPhysicalMinMireds default = 0x009A;
+ ram attribute colorTempPhysicalMaxMireds default = 0x01C6;
+ ram attribute coupleColorTempToLevelMinMireds;
+ persist attribute startUpColorTemperatureMireds default = 0x00FA;
+ ram attribute featureMap default = 0x1F;
+ ram attribute clusterRevision default = 7;
+
+ handle command MoveToHue;
+ handle command MoveHue;
+ handle command StepHue;
+ handle command MoveToSaturation;
+ handle command MoveSaturation;
+ handle command StepSaturation;
+ handle command MoveToHueAndSaturation;
+ handle command MoveToColor;
+ handle command MoveColor;
+ handle command StepColor;
+ handle command MoveToColorTemperature;
+ handle command EnhancedMoveToHue;
+ handle command EnhancedMoveHue;
+ handle command EnhancedStepHue;
+ handle command EnhancedMoveToHueAndSaturation;
+ handle command ColorLoopSet;
+ handle command StopMoveStep;
+ handle command MoveColorTemperature;
+ handle command StepColorTemperature;
+ }
+
+ server cluster SampleExternalManufacturerSpecific {
+ emits event PingCountEvent;
+ ram attribute flipFlop default = false;
+ callback attribute generatedCommandList;
+ callback attribute acceptedCommandList;
+ callback attribute attributeList;
+ ram attribute featureMap default = 0;
+ ram attribute clusterRevision default = 1;
+
+ handle command Ping;
+ handle command AddArgumentsResponse;
+ handle command AddArguments;
+ }
+}
+
+
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/manufacturer-specific-app.zap b/examples/manufacturer-specific-app/manufacturer-specific-common/manufacturer-specific-app.zap
new file mode 100644
index 00000000000000..a4f6ed7301cc75
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/manufacturer-specific-app.zap
@@ -0,0 +1,5813 @@
+{
+ "fileFormat": 2,
+ "featureLevel": 104,
+ "creator": "zap",
+ "keyValuePairs": [
+ {
+ "key": "commandDiscovery",
+ "value": "1"
+ },
+ {
+ "key": "defaultResponsePolicy",
+ "value": "always"
+ },
+ {
+ "key": "manufacturerCodes",
+ "value": "0x1002"
+ }
+ ],
+ "package": [
+ {
+ "pathRelativity": "relativeToZap",
+ "path": "../../../src/app/zap-templates/zcl/zcl.json",
+ "type": "zcl-properties",
+ "category": "matter",
+ "version": 1,
+ "description": "Matter SDK ZCL data"
+ },
+ {
+ "pathRelativity": "relativeToZap",
+ "path": "../../../src/app/zap-templates/app-templates.json",
+ "type": "gen-templates-json",
+ "category": "matter",
+ "version": "chip-v1"
+ },
+ {
+ "pathRelativity": "relativeToZap",
+ "path": "../nrfconnect/manufacturer-specific/xml/sample-external-manufacturer-specific-cluster.xml",
+ "type": "zcl-xml-standalone"
+ }
+ ],
+ "endpointTypes": [
+ {
+ "id": 1,
+ "name": "MA-rootdevice",
+ "deviceTypeRef": {
+ "code": 22,
+ "profileId": 259,
+ "label": "MA-rootdevice",
+ "name": "MA-rootdevice",
+ "deviceTypeOrder": 0
+ },
+ "deviceTypes": [
+ {
+ "code": 22,
+ "profileId": 259,
+ "label": "MA-rootdevice",
+ "name": "MA-rootdevice",
+ "deviceTypeOrder": 0
+ }
+ ],
+ "deviceVersions": [
+ 1
+ ],
+ "deviceIdentifiers": [
+ 22
+ ],
+ "deviceTypeName": "MA-rootdevice",
+ "deviceTypeCode": 22,
+ "deviceTypeProfileId": 259,
+ "clusters": [
+ {
+ "name": "Descriptor",
+ "code": 29,
+ "mfgCode": null,
+ "define": "DESCRIPTOR_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "DeviceTypeList",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ServerList",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClientList",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PartsList",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Access Control",
+ "code": 31,
+ "mfgCode": null,
+ "define": "ACCESS_CONTROL_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "ACL",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "Extension",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "SubjectsPerAccessControlEntry",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "TargetsPerAccessControlEntry",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AccessControlEntriesPerFabric",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AttributeList",
+ "code": 65531,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "AccessControlEntryChanged",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "AccessControlExtensionChanged",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ },
+ {
+ "name": "Basic Information",
+ "code": 40,
+ "mfgCode": null,
+ "define": "BASIC_INFORMATION_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "DataModelRevision",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "VendorName",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "VendorID",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "vendor_id",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ProductName",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ProductID",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "NodeLabel",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "Location",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "HardwareVersion",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "HardwareVersionString",
+ "code": 8,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "SoftwareVersion",
+ "code": 9,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "SoftwareVersionString",
+ "code": 10,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ManufacturingDate",
+ "code": 11,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "PartNumber",
+ "code": 12,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ProductURL",
+ "code": 13,
+ "mfgCode": null,
+ "side": "server",
+ "type": "long_char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ProductLabel",
+ "code": 14,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "SerialNumber",
+ "code": 15,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "LocalConfigDisabled",
+ "code": 16,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "UniqueID",
+ "code": 18,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CapabilityMinima",
+ "code": 19,
+ "mfgCode": null,
+ "side": "server",
+ "type": "CapabilityMinimaStruct",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "SpecificationVersion",
+ "code": 21,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "MaxPathsPerInvoke",
+ "code": 22,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 1,
+ "bounded": 0,
+ "defaultValue": "3",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "StartUp",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "ShutDown",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "Leave",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ },
+ {
+ "name": "OTA Software Update Provider",
+ "code": 41,
+ "mfgCode": null,
+ "define": "OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER",
+ "side": "client",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "QueryImage",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "QueryImageResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ApplyUpdateRequest",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "ApplyUpdateResponse",
+ "code": 3,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "NotifyUpdateApplied",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 0,
+ "isEnabled": 1
+ }
+ ]
+ },
+ {
+ "name": "OTA Software Update Requestor",
+ "code": 42,
+ "mfgCode": null,
+ "define": "OTA_SOFTWARE_UPDATE_REQUESTOR_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "AnnounceOTAProvider",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "DefaultOTAProviders",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "UpdatePossible",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "UpdateState",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "UpdateStateEnum",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "UpdateStateProgress",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "StateTransition",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "VersionApplied",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "DownloadError",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ },
+ {
+ "name": "General Commissioning",
+ "code": 48,
+ "mfgCode": null,
+ "define": "GENERAL_COMMISSIONING_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "ArmFailSafe",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ArmFailSafeResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "SetRegulatoryConfig",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "SetRegulatoryConfigResponse",
+ "code": 3,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "CommissioningComplete",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "CommissioningCompleteResponse",
+ "code": 5,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "Breadcrumb",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000000000000000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "BasicCommissioningInfo",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "BasicCommissioningInfo",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RegulatoryConfig",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "RegulatoryLocationTypeEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "LocationCapability",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "RegulatoryLocationTypeEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "SupportsConcurrentConnection",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Network Commissioning",
+ "code": 49,
+ "mfgCode": null,
+ "define": "NETWORK_COMMISSIONING_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "ScanNetworks",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ScanNetworksResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddOrUpdateWiFiNetwork",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddOrUpdateThreadNetwork",
+ "code": 3,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveNetwork",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "NetworkConfigResponse",
+ "code": 5,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "ConnectNetwork",
+ "code": 6,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ConnectNetworkResponse",
+ "code": 7,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "ReorderNetwork",
+ "code": 8,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "MaxNetworks",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "Networks",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ScanMaxTimeSeconds",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ConnectMaxTimeSeconds",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "InterfaceEnabled",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "LastNetworkingStatus",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "NetworkCommissioningStatusEnum",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "LastNetworkID",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "octet_string",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "LastConnectErrorValue",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32s",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "2",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Diagnostic Logs",
+ "code": 50,
+ "mfgCode": null,
+ "define": "DIAGNOSTIC_LOGS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "RetrieveLogsRequest",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "General Diagnostics",
+ "code": 51,
+ "mfgCode": null,
+ "define": "GENERAL_DIAGNOSTICS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "TestEventTrigger",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "TimeSnapshot",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "TimeSnapshotResponse",
+ "code": 2,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "NetworkInterfaces",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RebootCount",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "UpTime",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "TotalOperationalHours",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "BootReason",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "BootReasonEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ActiveHardwareFaults",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ActiveRadioFaults",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ActiveNetworkFaults",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "TestEventTriggersEnabled",
+ "code": 8,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "false",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "HardwareFaultChange",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "RadioFaultChange",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "NetworkFaultChange",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "BootReason",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ },
+ {
+ "name": "Software Diagnostics",
+ "code": 52,
+ "mfgCode": null,
+ "define": "SOFTWARE_DIAGNOSTICS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "ResetWatermarks",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "ThreadMetrics",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentHeapFree",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentHeapUsed",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentHeapHighWatermark",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Thread Network Diagnostics",
+ "code": 53,
+ "mfgCode": null,
+ "define": "THREAD_NETWORK_DIAGNOSTICS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "ResetCounts",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "Channel",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RoutingRole",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "RoutingRoleEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "NetworkName",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "char_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "PanId",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ExtendedPanId",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "MeshLocalPrefix",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "octet_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "OverrunCount",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "NeighborTable",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RouteTable",
+ "code": 8,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "PartitionId",
+ "code": 9,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "Weighting",
+ "code": 10,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "DataVersion",
+ "code": 11,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "StableDataVersion",
+ "code": 12,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "LeaderRouterId",
+ "code": 13,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "DetachedRoleCount",
+ "code": 14,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ChildRoleCount",
+ "code": 15,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RouterRoleCount",
+ "code": 16,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "LeaderRoleCount",
+ "code": 17,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "AttachAttemptCount",
+ "code": 18,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "PartitionIdChangeCount",
+ "code": 19,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "BetterPartitionAttachAttemptCount",
+ "code": 20,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ParentChangeCount",
+ "code": 21,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxTotalCount",
+ "code": 22,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxUnicastCount",
+ "code": 23,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxBroadcastCount",
+ "code": 24,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxAckRequestedCount",
+ "code": 25,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxAckedCount",
+ "code": 26,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxNoAckRequestedCount",
+ "code": 27,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxDataCount",
+ "code": 28,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxDataPollCount",
+ "code": 29,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxBeaconCount",
+ "code": 30,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxBeaconRequestCount",
+ "code": 31,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxOtherCount",
+ "code": 32,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxRetryCount",
+ "code": 33,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxDirectMaxRetryExpiryCount",
+ "code": 34,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxIndirectMaxRetryExpiryCount",
+ "code": 35,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxErrCcaCount",
+ "code": 36,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxErrAbortCount",
+ "code": 37,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxErrBusyChannelCount",
+ "code": 38,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxTotalCount",
+ "code": 39,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxUnicastCount",
+ "code": 40,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxBroadcastCount",
+ "code": 41,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxDataCount",
+ "code": 42,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxDataPollCount",
+ "code": 43,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxBeaconCount",
+ "code": 44,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxBeaconRequestCount",
+ "code": 45,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxOtherCount",
+ "code": 46,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxAddressFilteredCount",
+ "code": 47,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxDestAddrFilteredCount",
+ "code": 48,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxDuplicatedCount",
+ "code": 49,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxErrNoFrameCount",
+ "code": 50,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxErrUnknownNeighborCount",
+ "code": 51,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxErrInvalidSrcAddrCount",
+ "code": 52,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxErrSecCount",
+ "code": 53,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxErrFcsCount",
+ "code": 54,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RxErrOtherCount",
+ "code": 55,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ActiveTimestamp",
+ "code": 56,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PendingTimestamp",
+ "code": 57,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "Delay",
+ "code": 58,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "SecurityPolicy",
+ "code": 59,
+ "mfgCode": null,
+ "side": "server",
+ "type": "SecurityPolicy",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ChannelPage0Mask",
+ "code": 60,
+ "mfgCode": null,
+ "side": "server",
+ "type": "octet_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "OperationalDatasetComponents",
+ "code": 61,
+ "mfgCode": null,
+ "side": "server",
+ "type": "OperationalDatasetComponents",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ActiveNetworkFaultsList",
+ "code": 62,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x000F",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "2",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Wi-Fi Network Diagnostics",
+ "code": 54,
+ "mfgCode": null,
+ "define": "WIFI_NETWORK_DIAGNOSTICS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "ResetCounts",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "BSSID",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "octet_string",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "SecurityType",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "SecurityTypeEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "WiFiVersion",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "WiFiVersionEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ChannelNumber",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RSSI",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8s",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "BeaconLostCount",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "BeaconRxCount",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PacketMulticastRxCount",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PacketMulticastTxCount",
+ "code": 8,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PacketUnicastRxCount",
+ "code": 9,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PacketUnicastTxCount",
+ "code": 10,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int32u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentMaxRate",
+ "code": 11,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "OverrunCount",
+ "code": 12,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "3",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "Disconnection",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "AssociationFailure",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ },
+ {
+ "name": "ConnectionStatus",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ },
+ {
+ "name": "Ethernet Network Diagnostics",
+ "code": 55,
+ "mfgCode": null,
+ "define": "ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "ResetCounts",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "PHYRate",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "PHYRateEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FullDuplex",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PacketRxCount",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "PacketTxCount",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TxErrCount",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CollisionCount",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "OverrunCount",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CarrierDetect",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "TimeSinceReset",
+ "code": 8,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int64u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "3",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Switch",
+ "code": 59,
+ "mfgCode": null,
+ "define": "SWITCH_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "NumberOfPositions",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "2",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentPosition",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "2",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "SwitchLatched",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ },
+ {
+ "name": "Administrator Commissioning",
+ "code": 60,
+ "mfgCode": null,
+ "define": "ADMINISTRATOR_COMMISSIONING_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "OpenCommissioningWindow",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "OpenBasicCommissioningWindow",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "RevokeCommissioning",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "WindowStatus",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "CommissioningWindowStatusEnum",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AdminFabricIndex",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "fabric_idx",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AdminVendorId",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "vendor_id",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Operational Credentials",
+ "code": 62,
+ "mfgCode": null,
+ "define": "OPERATIONAL_CREDENTIALS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "AttestationRequest",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AttestationResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "CertificateChainRequest",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "CertificateChainResponse",
+ "code": 3,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "CSRRequest",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "CSRResponse",
+ "code": 5,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddNOC",
+ "code": 6,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "UpdateNOC",
+ "code": 7,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "NOCResponse",
+ "code": 8,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "UpdateFabricLabel",
+ "code": 9,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveFabric",
+ "code": 10,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddTrustedRootCertificate",
+ "code": 11,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "NOCs",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "Fabrics",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "SupportedFabrics",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CommissionedFabrics",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "TrustedRootCertificates",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentFabricIndex",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Group Key Management",
+ "code": 63,
+ "mfgCode": null,
+ "define": "GROUP_KEY_MANAGEMENT_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "KeySetWrite",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "KeySetRead",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "KeySetReadResponse",
+ "code": 2,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "KeySetRemove",
+ "code": 3,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "KeySetReadAllIndices",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "KeySetReadAllIndicesResponse",
+ "code": 5,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "GroupKeyMap",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "GroupTable",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "MaxGroupsPerFabric",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "MaxGroupKeysPerFabric",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Fixed Label",
+ "code": 64,
+ "mfgCode": null,
+ "define": "FIXED_LABEL_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "LabelList",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "User Label",
+ "code": 65,
+ "mfgCode": null,
+ "define": "USER_LABEL_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "LabelList",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 2,
+ "name": "MA-dimmablelight",
+ "deviceTypeRef": {
+ "code": 257,
+ "profileId": 259,
+ "label": "MA-dimmablelight",
+ "name": "MA-dimmablelight",
+ "deviceTypeOrder": 0
+ },
+ "deviceTypes": [
+ {
+ "code": 257,
+ "profileId": 259,
+ "label": "MA-dimmablelight",
+ "name": "MA-dimmablelight",
+ "deviceTypeOrder": 0
+ }
+ ],
+ "deviceVersions": [
+ 1
+ ],
+ "deviceIdentifiers": [
+ 257
+ ],
+ "deviceTypeName": "MA-dimmablelight",
+ "deviceTypeCode": 257,
+ "deviceTypeProfileId": 259,
+ "clusters": [
+ {
+ "name": "Identify",
+ "code": 3,
+ "mfgCode": null,
+ "define": "IDENTIFY_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "Identify",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "TriggerEffect",
+ "code": 64,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "IdentifyTime",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "IdentifyType",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "IdentifyTypeEnum",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "4",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Groups",
+ "code": 4,
+ "mfgCode": null,
+ "define": "GROUPS_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "AddGroup",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddGroupResponse",
+ "code": 0,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "ViewGroup",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ViewGroupResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "GetGroupMembership",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "GetGroupMembershipResponse",
+ "code": 2,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveGroup",
+ "code": 3,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveGroupResponse",
+ "code": 3,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveAllGroups",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddGroupIfIdentifying",
+ "code": 5,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "NameSupport",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "NameSupportBitmap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "4",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "On/Off",
+ "code": 6,
+ "mfgCode": null,
+ "define": "ON_OFF_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "Off",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "On",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "Toggle",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "OffWithEffect",
+ "code": 64,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "OnWithRecallGlobalScene",
+ "code": 65,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "OnWithTimedOff",
+ "code": 66,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "OnOff",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "GlobalSceneControl",
+ "code": 16384,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x01",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "OnTime",
+ "code": 16385,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "OffWaitTime",
+ "code": 16386,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "StartUpOnOff",
+ "code": 16387,
+ "mfgCode": null,
+ "side": "server",
+ "type": "StartUpOnOffEnum",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0xFF",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "5",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Level Control",
+ "code": 8,
+ "mfgCode": null,
+ "define": "LEVEL_CONTROL_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "MoveToLevel",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "Move",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "Step",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "Stop",
+ "code": 3,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveToLevelWithOnOff",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveWithOnOff",
+ "code": 5,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StepWithOnOff",
+ "code": 6,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StopWithOnOff",
+ "code": 7,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "CurrentLevel",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0xFE",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RemainingTime",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "MinLevel",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x01",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "MaxLevel",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0xFE",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentFrequency",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "MinFrequency",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "MaxFrequency",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "Options",
+ "code": 15,
+ "mfgCode": null,
+ "side": "server",
+ "type": "OptionsBitmap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "OnOffTransitionTime",
+ "code": 16,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "OnLevel",
+ "code": 17,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0xFF",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "OnTransitionTime",
+ "code": 18,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "OffTransitionTime",
+ "code": 19,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "DefaultMoveRate",
+ "code": 20,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "50",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "StartUpCurrentLevel",
+ "code": 16384,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "255",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "3",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "6",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Descriptor",
+ "code": 29,
+ "mfgCode": null,
+ "define": "DESCRIPTOR_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "attributes": [
+ {
+ "name": "DeviceTypeList",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ServerList",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClientList",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "PartsList",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Scenes Management",
+ "code": 98,
+ "mfgCode": null,
+ "define": "SCENES_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "apiMaturity": "provisional",
+ "commands": [
+ {
+ "name": "AddScene",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddSceneResponse",
+ "code": 0,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "ViewScene",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ViewSceneResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveScene",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveSceneResponse",
+ "code": 2,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveAllScenes",
+ "code": 3,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "RemoveAllScenesResponse",
+ "code": 3,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "StoreScene",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StoreSceneResponse",
+ "code": 4,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "RecallScene",
+ "code": 5,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "GetSceneMembership",
+ "code": 6,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "GetSceneMembershipResponse",
+ "code": 6,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "CopyScene",
+ "code": 64,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "LastConfiguredBy",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "node_id",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "SceneTableSize",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "16",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FabricSceneInfo",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "GeneratedCommandList",
+ "code": 65528,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AcceptedCommandList",
+ "code": 65529,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AttributeList",
+ "code": 65531,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Color Control",
+ "code": 768,
+ "mfgCode": null,
+ "define": "COLOR_CONTROL_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "MoveToHue",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveHue",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StepHue",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveToSaturation",
+ "code": 3,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveSaturation",
+ "code": 4,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StepSaturation",
+ "code": 5,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveToHueAndSaturation",
+ "code": 6,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveToColor",
+ "code": 7,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveColor",
+ "code": 8,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StepColor",
+ "code": 9,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveToColorTemperature",
+ "code": 10,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "EnhancedMoveToHue",
+ "code": 64,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "EnhancedMoveHue",
+ "code": 65,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "EnhancedStepHue",
+ "code": 66,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "EnhancedMoveToHueAndSaturation",
+ "code": 67,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "ColorLoopSet",
+ "code": 68,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StopMoveStep",
+ "code": 71,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "MoveColorTemperature",
+ "code": 75,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "StepColorTemperature",
+ "code": 76,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "CurrentHue",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentSaturation",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "RemainingTime",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentX",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x616B",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentY",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x607D",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorTemperatureMireds",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00FA",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorMode",
+ "code": 8,
+ "mfgCode": null,
+ "side": "server",
+ "type": "ColorModeEnum",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x01",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "Options",
+ "code": 15,
+ "mfgCode": null,
+ "side": "server",
+ "type": "OptionsBitmap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "NumberOfPrimaries",
+ "code": 16,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "EnhancedCurrentHue",
+ "code": 16384,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "EnhancedColorMode",
+ "code": 16385,
+ "mfgCode": null,
+ "side": "server",
+ "type": "EnhancedColorModeEnum",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x01",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorLoopActive",
+ "code": 16386,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorLoopDirection",
+ "code": 16387,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int8u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorLoopTime",
+ "code": 16388,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0019",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorLoopStartEnhancedHue",
+ "code": 16389,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x2300",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorLoopStoredEnhancedHue",
+ "code": 16390,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorCapabilities",
+ "code": 16394,
+ "mfgCode": null,
+ "side": "server",
+ "type": "ColorCapabilitiesBitmap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x1F",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorTempPhysicalMinMireds",
+ "code": 16395,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x009A",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "ColorTempPhysicalMaxMireds",
+ "code": 16396,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x01C6",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "CoupleColorTempToLevelMinMireds",
+ "code": 16397,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "StartUpColorTemperatureMireds",
+ "code": 16400,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "NVM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00FA",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x1F",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "7",
+ "reportable": 1,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Sample External Manufacturer-Specific",
+ "code": 4294048801,
+ "mfgCode": null,
+ "define": "SAMPLE_EXTERNAL_MANUFACTURER_SPECIFIC_CLUSTER",
+ "side": "server",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "Ping",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddArgumentsResponse",
+ "code": 1,
+ "mfgCode": null,
+ "source": "server",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "AddArguments",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 1,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "FlipFlop",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "boolean",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "false",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "GeneratedCommandList",
+ "code": 65528,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AcceptedCommandList",
+ "code": 65529,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AttributeList",
+ "code": 65531,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "External",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": null,
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ],
+ "events": [
+ {
+ "name": "PingCountEvent",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "endpoints": [
+ {
+ "endpointTypeName": "MA-rootdevice",
+ "endpointTypeIndex": 0,
+ "profileId": 259,
+ "endpointId": 0,
+ "networkId": 0,
+ "parentEndpointIdentifier": null
+ },
+ {
+ "endpointTypeName": "MA-dimmablelight",
+ "endpointTypeIndex": 1,
+ "profileId": 259,
+ "endpointId": 1,
+ "networkId": 0,
+ "parentEndpointIdentifier": null
+ }
+ ]
+}
\ No newline at end of file
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/src/ColorFormat.cpp b/examples/manufacturer-specific-app/manufacturer-specific-common/src/ColorFormat.cpp
new file mode 100644
index 00000000000000..bfe1891d6a53de
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/src/ColorFormat.cpp
@@ -0,0 +1,183 @@
+/*
+ *
+ * Copyright (c) 2021 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ColorFormat.h"
+
+#include <math.h>
+
+// define a clamp macro to substitute the std::clamp macro which is available from C++17 onwards
+#define clamp(a, min, max) ((a) < (min) ? (min) : ((a) > (max) ? (max) : (a)))
+
+RgbColor_t HsvToRgb(HsvColor_t hsv)
+{
+ RgbColor_t rgb;
+
+ uint8_t region, p, q, t;
+ uint32_t h, s, v, remainder;
+
+ if (hsv.s == 0)
+ {
+ rgb.r = rgb.g = rgb.b = hsv.v;
+ }
+ else
+ {
+ h = hsv.h;
+ s = hsv.s;
+ v = hsv.v;
+
+ region = h / 43;
+ remainder = (h - (region * 43)) * 6;
+ p = (v * (255 - s)) >> 8;
+ q = (v * (255 - ((s * remainder) >> 8))) >> 8;
+ t = (v * (255 - ((s * (255 - remainder)) >> 8))) >> 8;
+ switch (region)
+ {
+ case 0:
+ rgb.r = v, rgb.g = t, rgb.b = p;
+ break;
+ case 1:
+ rgb.r = q, rgb.g = v, rgb.b = p;
+ break;
+ case 2:
+ rgb.r = p, rgb.g = v, rgb.b = t;
+ break;
+ case 3:
+ rgb.r = p, rgb.g = q, rgb.b = v;
+ break;
+ case 4:
+ rgb.r = t, rgb.g = p, rgb.b = v;
+ break;
+ case 5:
+ default:
+ rgb.r = v, rgb.g = p, rgb.b = q;
+ break;
+ }
+ }
+
+ return rgb;
+}
+
+RgbColor_t XYToRgb(uint8_t Level, uint16_t currentX, uint16_t currentY)
+{
+ // convert xyY color space to RGB
+
+ // https://www.easyrgb.com/en/math.php
+ // https://en.wikipedia.org/wiki/SRGB
+ // refer https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_xy_chromaticity_diagram_and_the_CIE_xyY_color_space
+
+ // The currentX/currentY attribute contains the current value of the normalized chromaticity value of x/y.
+ // The value of x/y shall be related to the currentX/currentY attribute by the relationship
+ // x = currentX/65536
+ // y = currentY/65536
+ // z = 1-x-y
+
+ RgbColor_t rgb;
+
+ float x, y, z;
+ float X, Y, Z;
+ float r, g, b;
+
+ x = (static_cast<float>(currentX)) / 65535.0f;
+ y = (static_cast<float>(currentY)) / 65535.0f;
+
+ z = 1.0f - x - y;
+
+ // Calculate XYZ values
+
+ // Y - given brightness in 0 - 1 range
+ Y = (static_cast<float>(Level)) / 254.0f;
+ X = (Y / y) * x;
+ Z = (Y / y) * z;
+
+ // X, Y and Z input refer to a D65/2° standard illuminant.
+ // sR, sG and sB (standard RGB) output range = 0 ÷ 255
+ // convert XYZ to RGB - CIE XYZ to sRGB
+ r = (X * 3.2410f) - (Y * 1.5374f) - (Z * 0.4986f);
+ g = -(X * 0.9692f) + (Y * 1.8760f) + (Z * 0.0416f);
+ b = (X * 0.0556f) - (Y * 0.2040f) + (Z * 1.0570f);
+
+ // apply gamma 2.2 correction
+ r = (r <= 0.00304f ? 12.92f * r : (1.055f) * pow(r, (1.0f / 2.4f)) - 0.055f);
+ g = (g <= 0.00304f ? 12.92f * g : (1.055f) * pow(g, (1.0f / 2.4f)) - 0.055f);
+ b = (b <= 0.00304f ? 12.92f * b : (1.055f) * pow(b, (1.0f / 2.4f)) - 0.055f);
+
+ // Round off
+ r = clamp(r, 0, 1);
+ g = clamp(g, 0, 1);
+ b = clamp(b, 0, 1);
+
+ // these rgb values are in the range of 0 to 1, convert to limit of HW specific LED
+ rgb.r = (uint8_t) (r * 255);
+ rgb.g = (uint8_t) (g * 255);
+ rgb.b = (uint8_t) (b * 255);
+
+ return rgb;
+}
+
+RgbColor_t CTToRgb(CtColor_t ct)
+{
+ RgbColor_t rgb;
+ float r, g, b;
+
+ // Algorithm credits to Tanner Helland: https://tannerhelland.com/2012/09/18/convert-temperature-rgb-algorithm-code.html
+
+ // Convert Mireds to centiKelvins. k = 1,000,000/mired
+ float ctCentiKelvin = 10000 / static_cast<float>(ct.ctMireds);
+
+ // Red
+ if (ctCentiKelvin <= 66)
+ {
+ r = 255;
+ }
+ else
+ {
+ r = 329.698727446f * pow(ctCentiKelvin - 60, -0.1332047592f);
+ }
+
+ // Green
+ if (ctCentiKelvin <= 66)
+ {
+ g = 99.4708025861f * log(ctCentiKelvin) - 161.1195681661f;
+ }
+ else
+ {
+ g = 288.1221695283f * pow(ctCentiKelvin - 60, -0.0755148492f);
+ }
+
+ // Blue
+ if (ctCentiKelvin >= 66)
+ {
+ b = 255;
+ }
+ else
+ {
+ if (ctCentiKelvin <= 19)
+ {
+ b = 0;
+ }
+ else
+ {
+ b = 138.5177312231f * log(ctCentiKelvin - 10) - 305.0447927307f;
+ }
+ }
+ rgb.r = (uint8_t) clamp(r, 0, 255);
+ rgb.g = (uint8_t) clamp(g, 0, 255);
+ rgb.b = (uint8_t) clamp(b, 0, 255);
+
+ return rgb;
+}
diff --git a/examples/manufacturer-specific-app/manufacturer-specific-common/src/LightingManager.cpp b/examples/manufacturer-specific-app/manufacturer-specific-common/src/LightingManager.cpp
new file mode 100644
index 00000000000000..55461dcb05c6b8
--- /dev/null
+++ b/examples/manufacturer-specific-app/manufacturer-specific-common/src/LightingManager.cpp
@@ -0,0 +1,102 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * Copyright (c) 2019 Google LLC.
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LightingManager.h"
+
+#include <lib/support/logging/CHIPLogging.h>
+
+LightingManager LightingManager::sLight;
+
+CHIP_ERROR LightingManager::Init()
+{
+ mState = kState_On;
+ return CHIP_NO_ERROR;
+}
+
+bool LightingManager::IsTurnedOn()
+{
+ return mState == kState_On;
+}
+
+void LightingManager::SetCallbacks(LightingCallback_fn aActionInitiated_CB, LightingCallback_fn aActionCompleted_CB)
+{
+ mActionInitiated_CB = aActionInitiated_CB;
+ mActionCompleted_CB = aActionCompleted_CB;
+}
+
+bool LightingManager::InitiateAction(Action_t aAction)
+{
+ // TODO: this function is called InitiateAction because we want to implement some features such as ramping up here.
+ bool action_initiated = false;
+ State_t new_state;
+
+ switch (aAction)
+ {
+ case ON_ACTION:
+ ChipLogProgress(AppServer, "LightingManager::InitiateAction(ON_ACTION)");
+ break;
+ case OFF_ACTION:
+ ChipLogProgress(AppServer, "LightingManager::InitiateAction(OFF_ACTION)");
+ break;
+ default:
+ ChipLogProgress(AppServer, "LightingManager::InitiateAction(unknown)");
+ break;
+ }
+
+ // Initiate On/Off Action only when the previous one is complete.
+ if (mState == kState_Off && aAction == ON_ACTION)
+ {
+ action_initiated = true;
+ new_state = kState_On;
+ }
+ else if (mState == kState_On && aAction == OFF_ACTION)
+ {
+ action_initiated = true;
+ new_state = kState_Off;
+ }
+
+ if (action_initiated)
+ {
+ if (mActionInitiated_CB)
+ {
+ mActionInitiated_CB(aAction);
+ }
+
+ Set(new_state == kState_On);
+
+ if (mActionCompleted_CB)
+ {
+ mActionCompleted_CB(aAction);
+ }
+ }
+
+ return action_initiated;
+}
+
+void LightingManager::Set(bool aOn)
+{
+ if (aOn)
+ {
+ mState = kState_On;
+ }
+ else
+ {
+ mState = kState_Off;
+ }
+}
diff --git a/examples/manufacturer-specific-app/nrfconnect/.gitignore b/examples/manufacturer-specific-app/nrfconnect/.gitignore
new file mode 100644
index 00000000000000..84c048a73cc2e5
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/.gitignore
@@ -0,0 +1 @@
+/build/
diff --git a/examples/manufacturer-specific-app/nrfconnect/CMakeLists.txt b/examples/manufacturer-specific-app/nrfconnect/CMakeLists.txt
new file mode 100644
index 00000000000000..0163b35f8b77f7
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/CMakeLists.txt
@@ -0,0 +1,233 @@
+#
+# Copyright (c) 2020 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+cmake_minimum_required(VERSION 3.13.1)
+
+get_filename_component(CHIP_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/third_party/connectedhomeip REALPATH)
+get_filename_component(NRFCONNECT_COMMON ${CHIP_ROOT}/examples/platform/nrfconnect REALPATH)
+get_filename_component(MANUFACTURER_SPECIFIC_COMMON ${CHIP_ROOT}/examples/manufacturer-specific-app/manufacturer-specific-common REALPATH)
+get_filename_component(GEN_DIR ${CHIP_ROOT}/zzz_generated/ REALPATH)
+
+include(${CHIP_ROOT}/config/nrfconnect/app/check-nrfconnect-version.cmake)
+
+list(APPEND ZEPHYR_EXTRA_MODULES ${CHIP_ROOT}/config/nrfconnect/chip-module)
+find_package(Zephyr HINTS $ENV{ZEPHYR_BASE})
+
+project(chip-nrfconnect-manufacturer-specific-app)
+
+include(${CHIP_ROOT}/config/nrfconnect/app/check-sysbuild-use.cmake)
+include(${CHIP_ROOT}/config/nrfconnect/app/enable-gnu-std.cmake)
+include(${CHIP_ROOT}/config/nrfconnect/app/flashing.cmake)
+include(${CHIP_ROOT}/src/app/chip_data_model.cmake)
+
+# -Wmaybe-uninitialized has too many false positives, including on std::optional
+# and chip::Optional. Make it nonfatal.
+#
+# See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80635
+target_compile_options(app PRIVATE -Werror -Wno-error=maybe-uninitialized)
+
+target_include_directories(app PRIVATE
+ main/include
+ ${MANUFACTURER_SPECIFIC_COMMON}
+ ${GEN_DIR}
+ # ${GEN_DIR}/app-common
+ ${GEN_DIR}/manufacturer-specific-app
+ ${NRFCONNECT_COMMON}/util/include
+ ${NRFCONNECT_COMMON}/app/include)
+
+target_sources(app PRIVATE
+ main/AppTask.cpp
+ main/main.cpp
+ main/ZclCallbacks.cpp
+ ${CHIP_ROOT}/src/app/util/persistence/DeferredAttributePersistenceProvider.cpp
+ ${NRFCONNECT_COMMON}/util/LEDWidget.cpp
+ ${NRFCONNECT_COMMON}/util/PWMDevice.cpp)
+
+# add on manufacturer specific cluster
+target_sources(app PRIVATE
+ manufacturer-specific/clusters/sample-external-manufacturer-specific-server.cpp
+ manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
+ manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
+)
+
+target_include_directories(app PUBLIC
+ manufacturer-specific/clusters/
+ manufacturer-specific/zzz_generated/app-common
+)
+
+chip_configure_data_model(app
+ ZAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/../manufacturer-specific-common/manufacturer-specific-app.zap
+ TEMPLATES_JSON ${CMAKE_CURRENT_SOURCE_DIR}/manufacturer-specific/app-templates.json
+ EXTERNAL_CLUSTERS SAMPLE_EXTERNAL_MANUFACTURER_SPECIFIC_CLUSTER
+ EXTERNAL_APP_COMMON manufacturer-specific/zzz_generated/app-common
+)
+
+if(CONFIG_CHIP_OTA_REQUESTOR OR CONFIG_MCUMGR_TRANSPORT_BT)
+ target_sources(app PRIVATE ${NRFCONNECT_COMMON}/util/OTAUtil.cpp)
+endif()
+
+if(CONFIG_MCUMGR_TRANSPORT_BT)
+ zephyr_library_link_libraries(MCUBOOT_BOOTUTIL)
+ target_sources(app PRIVATE ${NRFCONNECT_COMMON}/util/DFUOverSMP.cpp)
+endif()
+
+if (CONFIG_SHELL AND BOARD STREQUAL "nrf52840dongle_nrf52840")
+ target_sources(app PRIVATE ${NRFCONNECT_COMMON}/util/DFUTrigger.cpp)
+endif()
+
+if (CONFIG_CHIP_PW_RPC)
+
+# Make all targets created below depend on zephyr_interface to inherit MCU-related compilation flags
+link_libraries($<BUILD_INTERFACE:zephyr_interface>)
+
+set(PIGWEED_ROOT "${CHIP_ROOT}/third_party/pigweed/repo")
+include(${PIGWEED_ROOT}/pw_build/pigweed.cmake)
+include(${PIGWEED_ROOT}/pw_protobuf_compiler/proto.cmake)
+
+pw_set_module_config(pw_rpc_CONFIG pw_rpc.disable_global_mutex_config)
+pw_set_backend(pw_log pw_log_basic)
+pw_set_backend(pw_assert.check pw_assert_log.check_backend)
+pw_set_backend(pw_assert.assert pw_assert.assert_compatibility_backend)
+pw_set_backend(pw_sys_io pw_sys_io.nrfconnect)
+set(dir_pw_third_party_nanopb "${CHIP_ROOT}/third_party/nanopb/repo" CACHE STRING "" FORCE)
+
+add_subdirectory(third_party/connectedhomeip/examples/platform/nrfconnect/pw_sys_io)
+add_subdirectory(third_party/connectedhomeip/third_party/nanopb/repo)
+add_subdirectory(third_party/connectedhomeip/third_party/pigweed/repo)
+
+pw_proto_library(attributes_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/attributes_service.proto
+ INPUTS
+ ${CHIP_ROOT}/examples/common/pigweed/protos/attributes_service.options
+ PREFIX
+ attributes_service
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ DEPS
+ pw_protobuf.common_proto
+)
+
+pw_proto_library(button_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/button_service.proto
+ PREFIX
+ button_service
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ DEPS
+ pw_protobuf.common_proto
+)
+
+pw_proto_library(descriptor_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/descriptor_service.proto
+ PREFIX
+ descriptor_service
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ DEPS
+ pw_protobuf.common_proto
+)
+
+pw_proto_library(device_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/device_service.proto
+ INPUTS
+ ${CHIP_ROOT}/examples/common/pigweed/protos/device_service.options
+ PREFIX
+ device_service
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ DEPS
+ pw_protobuf.common_proto
+)
+
+pw_proto_library(lighting_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/lighting_service.proto
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ PREFIX
+ lighting_service
+ DEPS
+ pw_protobuf.common_proto
+)
+
+pw_proto_library(ot_cli_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/ot_cli_service.proto
+ INPUTS
+ ${CHIP_ROOT}/examples/common/pigweed/protos/ot_cli_service.options
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ PREFIX
+ ot_cli_service
+ DEPS
+ pw_protobuf.common_proto
+)
+
+pw_proto_library(thread_service
+ SOURCES
+ ${CHIP_ROOT}/examples/common/pigweed/protos/thread_service.proto
+ INPUTS
+ ${CHIP_ROOT}/examples/common/pigweed/protos/thread_service.options
+ STRIP_PREFIX
+ ${CHIP_ROOT}/examples/common/pigweed/protos
+ PREFIX
+ thread_service
+ DEPS
+ pw_protobuf.common_proto
+)
+
+target_sources(app PRIVATE
+ ../../common/pigweed/RpcService.cpp
+ ../../common/pigweed/nrfconnect/PigweedLoggerMutex.cpp
+ ${NRFCONNECT_COMMON}/Rpc.cpp
+ ${NRFCONNECT_COMMON}/util/PigweedLogger.cpp
+)
+
+target_include_directories(app PRIVATE
+ ${CHIP_ROOT}/src/lib/support
+ ${CHIP_ROOT}/src/system
+ ${NRFCONNECT_COMMON}
+ ../../common
+ ../../common/pigweed
+ ../../common/pigweed/nrfconnect)
+
+target_compile_options(app PRIVATE
+ "-DPW_RPC_ATTRIBUTE_SERVICE=1"
+ "-DPW_RPC_BUTTON_SERVICE=1"
+ "-DPW_RPC_DESCRIPTOR_SERVICE=1"
+ "-DPW_RPC_DEVICE_SERVICE=1"
+ "-DPW_RPC_LIGHTING_SERVICE=1"
+ "-DPW_RPC_THREAD_SERVICE=1"
+ )
+
+target_link_libraries(app PRIVATE
+ attributes_service.nanopb_rpc
+ button_service.nanopb_rpc
+ descriptor_service.nanopb_rpc
+ device_service.nanopb_rpc
+ lighting_service.nanopb_rpc
+ thread_service.nanopb_rpc
+ pw_checksum
+ pw_hdlc
+ pw_log
+ pw_rpc.server
+ pw_sys_io
+)
+
+endif(CONFIG_CHIP_PW_RPC)
diff --git a/examples/manufacturer-specific-app/nrfconnect/Kconfig b/examples/manufacturer-specific-app/nrfconnect/Kconfig
new file mode 100644
index 00000000000000..c48d15a66b5451
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/Kconfig
@@ -0,0 +1,34 @@
+#
+# Copyright (c) 2022 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+mainmenu "Matter nRF Connect External Manufacturer-specific Cluster Example Application"
+
+# Sample configuration used for Thread networking
+if NET_L2_OPENTHREAD
+
+choice OPENTHREAD_NORDIC_LIBRARY_CONFIGURATION
+ default OPENTHREAD_NORDIC_LIBRARY_FTD
+endchoice
+
+choice OPENTHREAD_DEVICE_TYPE
+ default OPENTHREAD_FTD
+endchoice
+
+endif # NET_L2_OPENTHREAD
+
+
+rsource "../../../config/nrfconnect/chip-module/Kconfig.features"
+rsource "../../../config/nrfconnect/chip-module/Kconfig.defaults"
+source "Kconfig.zephyr"
diff --git a/examples/manufacturer-specific-app/nrfconnect/Kconfig.sysbuild b/examples/manufacturer-specific-app/nrfconnect/Kconfig.sysbuild
new file mode 100644
index 00000000000000..4048c88bf51f0f
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/Kconfig.sysbuild
@@ -0,0 +1,79 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#### Radio core selection
+config NRF_DEFAULT_IPC_RADIO
+ default y
+
+# Enable IEEE802.15.4 serialization to network core
+config NETCORE_IPC_RADIO_IEEE802154
+ default y if (SOC_SERIES_NRF53X) && !WIFI_NRF700X
+
+# Enable Bluetooth serialization to network core
+config NETCORE_IPC_RADIO_BT_HCI_IPC
+ default y if SOC_SERIES_NRF53X
+
+config MATTER_OTA
+ default n if BOARD_NRF52840DONGLE_NRF52840
+
+#### Bootloader
+choice BOOTLOADER
+ default BOOTLOADER_MCUBOOT if !BOARD_NRF52840DONGLE_NRF52840
+endchoice
+
+if BOOTLOADER_MCUBOOT
+
+#### DFU multi-image support
+config DFU_MULTI_IMAGE_PACKAGE_BUILD
+ default y
+
+config DFU_MULTI_IMAGE_PACKAGE_APP
+ default y
+
+config PM_EXTERNAL_FLASH_MCUBOOT_SECONDARY
+ default y
+
+#### DFU network core configuration
+if SOC_SERIES_NRF53X
+
+config MCUBOOT_UPDATEABLE_IMAGES
+ default 2
+
+choice MCUBOOT_MODE
+ default MCUBOOT_MODE_OVERWRITE_ONLY
+endchoice
+
+choice BOOT_SIGNATURE_TYPE
+ default BOOT_SIGNATURE_TYPE_RSA
+endchoice
+
+config SECURE_BOOT_NETCORE
+ default y
+
+config NETCORE_APP_UPDATE
+ default y
+
+config DFU_MULTI_IMAGE_PACKAGE_NET
+ default y
+
+endif # SOC_SERIES_NRF53X
+endif # BOOTLOADER_MCUBOOT
+
+#### Enable generating factory data
+config MATTER_FACTORY_DATA_GENERATE
+ default y if !BOARD_NRF52840DONGLE_NRF52840
+
+source "${ZEPHYR_BASE}/share/sysbuild/Kconfig"
diff --git a/examples/manufacturer-specific-app/nrfconnect/README.md b/examples/manufacturer-specific-app/nrfconnect/README.md
new file mode 100644
index 00000000000000..62e4954d7be4c7
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/README.md
@@ -0,0 +1,594 @@
+# Matter nRF Connect Lighting Example Application
+
+> **Note:** This example is intended only to perform smoke tests of a Matter
+> solution integrated with nRF Connect SDK platform. The example quality is not
+> production ready and it may contain minor bugs or use not optimal
+> configuration. It is not recommended to use this example as a basis for
+> creating a market ready product.
+>
+> For the production ready and optimized Matter samples, see
+> [nRF Connect SDK samples](https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/samples/matter.html).
+> The Matter samples in nRF Connect SDK use various additional software
+> components and provide multiple optional features that improve the developer
+> and user experience. To read more about it, see
+> [Matter support in nRF Connect SDK](https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/protocols/matter/index.html#ug-matter)
+> page. Using Matter samples from nRF Connect SDK allows you to get a full
+> Nordic technical support via [DevZone](https://devzone.nordicsemi.com/)
+> portal.
+
+The nRF Connect Lighting Example demonstrates how to remotely control a white
+dimmable light bulb. It uses buttons to test changing the lighting and device
+states and LEDs to show the state of these changes. You can use this example as
+a reference for creating your own application.
+
+
+
+
+The example is based on
+[Matter](https://github.com/project-chip/connectedhomeip) and Nordic
+Semiconductor's nRF Connect SDK, and was created to facilitate testing and
+certification of a Matter device communicating over a low-power, 802.15.4 Thread
+network, or Wi-Fi network.
+
+The example behaves as a Matter accessory, that is a device that can be paired
+into an existing Matter network and can be controlled by this network. In the
+case of Thread, this device works as a Thread Sleepy End Device. Support for
+both Thread and Wi-Fi is mutually exclusive and depends on the hardware
+platform, so only one protocol can be supported for a specific light device.
+
+<hr>
+
+## Overview
+
+This example is running on the nRF Connect platform, which is based on Nordic
+Semiconductor's
+[nRF Connect SDK](https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/index.html)
+and [Zephyr RTOS](https://zephyrproject.org/). Visit Matter's
+[nRF Connect platform overview](../../../docs/platforms/nrf/nrfconnect_platform_overview.md)
+to read more about the platform structure and dependencies.
+
+By default, the Matter accessory device has IPv6 networking disabled. You must
+pair it with the Matter controller over Bluetooth® LE to get the configuration
+from the controller to use the device within a Thread or Wi-Fi network. The
+device starts advertising automatically and you can commission the device within
+15 minutes. If the advertising time elapsed you can re-enable it using buttons.
+See [Bluetooth LE advertising](#bluetooth-le-advertising) to learn how to do
+this. The controller must get the commissioning information from the Matter
+accessory device and provision the device into the network.
+
+You can test this application remotely over the Thread or the Wi-Fi protocol,
+which in either case requires more devices, including a Matter controller that
+you can configure either on a PC or a mobile device.
+
+The sample uses buttons for changing LED states to show the state of these
+changes. You can test it in the following ways:
+
+- Standalone, using a single DK that runs the lighting application.
+
+- Remotely over the Thread or the Wi-Fi protocol, which in either case
+ requires more devices, including a Matter controller that you can configure
+ either on a PC or a mobile device.
+
+### Bluetooth LE advertising
+
+In this example, to commission the device onto a Matter network, it must be
+discoverable over Bluetooth LE. For security reasons, you must start Bluetooth
+LE advertising manually after powering up the device by pressing:
+
+- On nRF52840 DK, nRF5340 DK, and nRF21540 DK: **Button 4**.
+
+- On nRF7002 DK: **Button 2**.
+
+### Bluetooth LE rendezvous
+
+In Matter, the commissioning procedure is done over Bluetooth LE between a
+Matter device and the Matter controller, where the controller has the
+commissioner role.
+
+To start the rendezvous, the controller must get the commissioning information
+from the Matter device. The data payload is encoded within a QR code, printed to
+the UART console, and shared using an NFC tag. The emulation of the NFC tag
+emulation starts automatically when Bluetooth LE advertising is started and
+stays enabled until Bluetooth LE advertising timeout expires.
+
+#### Thread or Wi-Fi provisioning
+
+The provisioning operation, which is the Last part of the rendezvous procedure,
+involves sending the Thread or Wi-Fi network credentials from the Matter
+controller to the Matter device. As a result, the device joins the Thread or
+Wi-Fi network and can communicate with other devices in the network.
+
+### Device Firmware Upgrade
+
+The example supports over-the-air (OTA) device firmware upgrade (DFU) using one
+of the two available methods:
+
+- Matter OTA update that is mandatory for Matter-compliant devices and enabled
+ by default
+- [Simple Management Protocol](https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/zephyr/guides/device_mgmt/index.html#device-mgmt)
+ over Bluetooth LE, an optional proprietary method that can be enabled to
+ work alongside the default Matter OTA update. Note that this protocol is not
+ a part of the Matter specification.
+
+For both methods, the
+[MCUboot](https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/mcuboot/index.html)
+bootloader solution is used to replace the old firmware image with the new one.
+
+#### Matter Over-the-Air Update
+
+The Matter over-the-air update distinguishes two types of nodes: OTA Provider
+and OTA Requestor.
+
+An OTA Provider is a node that hosts a new firmware image and is able to respond
+on an OTA Requestor's queries regarding availability of new firmware images or
+requests to start sending the update packages.
+
+An OTA Requestor is a node that wants to download a new firmware image and sends
+requests to an OTA Provider to start the update process.
+
+#### Simple Management Protocol
+
+Simple Management Protocol (SMP) is a basic transfer encoding that is used for
+device management purposes, including application image management. SMP supports
+using different transports, such as Bluetooth LE, UDP, or serial USB/UART.
+
+In this example, the Matter device runs the SMP Server to download the
+application update image using the Bluetooth LE transport.
+
+See the
+[Building with Device Firmware Upgrade support](#building-with-device-firmware-upgrade-support)
+section to learn how to enable SMP and use it for the DFU purpose in this
+example.
+
+#### Bootloader
+
+MCUboot is a secure bootloader used for swapping firmware images of different
+versions and generating proper build output files that can be used in the device
+firmware upgrade process.
+
+The bootloader solution requires an area of flash memory to swap application
+images during the firmware upgrade. Nordic Semiconductor devices use an external
+memory chip for this purpose. The memory chip communicates with the
+microcontroller through the QSPI bus.
+
+See the
+[Building with Device Firmware Upgrade support](#building-with-device-firmware-upgrade-support)
+section to learn how to change MCUboot and flash configuration in this example.
+
+<hr>
+
+## Requirements
+
+The application requires a specific revision of the nRF Connect SDK to work
+correctly. See [Setting up the environment](#setting-up-the-environment) for
+more information.
+
+### Supported devices
+
+The example supports building and running on the following devices:
+
+| Hardware platform | Build target | Platform image |
+| ------------------------------------------------------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [nRF52840 DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK) | `nrf52840dk/nrf52840` | <details><summary>nRF52840 DK</summary><img src="../../platform/nrfconnect/doc/images/nRF52840_DK_info-medium.jpg" alt="nRF52840 DK"/></details> |
+| [nRF5340 DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF5340-DK) | `nrf5340dk/nrf5340/cpuapp` | <details><summary>nRF5340 DK</summary><img src="../../platform/nrfconnect/doc/images/nRF5340_DK_info-medium.jpg" alt="nRF5340 DK"/></details> |
+| [nRF52840 Dongle](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-Dongle) | `nrf52840dongle/nrf52840` | <details><summary>nRF52840 Dongle</summary><img src="../../platform/nrfconnect/doc/images/nRF52840_Dongle-medium.jpg" alt="nRF52840 Dongle"/></details> |
+| [nRF7002 DK](https://www.nordicsemi.com/Products/Development-hardware/nRF7002-DK) | `nrf7002dk/nrf5340/cpuapp` | <details><summary>nRF7002 DK</summary><img src="../../platform/nrfconnect/doc/images/nRF7002-DK_Front-small.png" alt="nRF7002 DK"/></details> |
+
+<hr>
+
+### IPv6 network support
+
+The development kits for this sample offer the following IPv6 network support
+for Matter:
+
+- Matter over Thread is supported for `nrf52840dk/nrf52840` and
+ `nrf5340dk/nrf5340/cpuapp`.
+- Matter over Wi-Fi is supported for `nrf7002dk/nrf5340/cpuapp`.
+
+## Device UI
+
+This section lists the User Interface elements that you can use to control and
+monitor the state of the device. These correspond to PCB components on the
+platform image.
+
+> **Note**:
+>
+> The following Device UI elements are missing on the nRF52840 Dongle: **Button
+> 2**, **Button 3**, **Button 4**, **SEGGER J-Link USB port**, and **NFC port
+> with antenna attached**. You can collect logs from the nRF52840 Dongle using
+> the **nRF USB port** instead of the **SEGGER J-Link USB port**.
+> Functionalities associated with the remaining missing elements are
+> inaccessible.
+
+**LED 1** shows the overall state of the device and its connectivity. The
+following states are possible:
+
+- _Short Flash On (50 ms on/950 ms off)_ — The device is in the
+ unprovisioned (unpaired) state and is waiting for a commissioning
+ application to connect.
+
+- _Rapid Even Flashing (100 ms on/100 ms off)_ — The device is in the
+ unprovisioned state and a commissioning application is connected through
+ Bluetooth LE.
+
+- _Short Flash Off (950ms on/50ms off)_ — The device is fully
+ provisioned, but does not yet have full connectivity for Thread or Wi-Fi
+ network.
+
+- _Solid On_ — The device is fully provisioned.
+
+**LED 2** simulates the light bulb and shows the state of the lighting. The
+following states are possible:
+
+- _Solid On_ — The light bulb is on.
+
+- _Off_ — The light bulb is off.
+
+ Additionally, the LED starts blinking evenly (500 ms on/500 ms off) when the
+ Identify command of the Identify cluster is received on the endpoint 1. The
+ command’s argument can be used to specify the duration of the effect.
+
+**Button 1** can be used for the following purposes:
+
+- _Pressed for less than 3 s_ — Initiates the OTA software update
+ process. This feature is disabled by default, but can be enabled by
+ following the
+ [Building with Device Firmware Upgrade support](#building-with-device-firmware-upgrade-support)
+ instructions.
+
+- _Pressed for more than 3 s_ — initiates the factory reset of the
+ device. Releasing the button within the 3-second window cancels the factory
+ reset procedure.
+
+**Button 2** — Pressing the button once changes the lighting state to the
+opposite one.
+
+- On nRF52840 DK, nRF5340 DK, and nRF21540 DK: Changes the LED state to the
+ opposite one.
+
+- On nRF7002 DK:
+
+ - If pressed for less than three seconds, it changes the LED state to the
+ opposite one.
+
+ - If pressed for more than three seconds, it starts the NFC tag emulation,
+ enables Bluetooth LE advertising for the predefined period of time (15
+ minutes by default), and makes the device discoverable over Bluetooth
+ LE.
+
+**Button 4** :
+
+- On nRF52840 DK, nRF5340 DK, and nRF21540 DK: Starts the NFC tag emulation,
+ enables Bluetooth LE advertising for the predefined period of time (15
+ minutes by default), and makes the device discoverable over Bluetooth LE.
+ This button is used during the commissioning procedure.
+
+- On nRF7002 DK: Not available.
+
+**SEGGER J-Link USB port** can be used to get logs from the device or
+communicate with it using the
+[command line interface](../../../docs/platforms/nrf/nrfconnect_examples_cli.md).
+
+**NFC port with antenna attached** can be used to start the
+[rendezvous](#bluetooth-le-rendezvous) by providing the commissioning
+information from the Matter device in a data payload that can be shared using
+NFC.
+
+<hr>
+
+## Setting up the environment
+
+Before building the example, check out the Matter repository and sync submodules
+using the following command:
+
+ $ python3 scripts/checkout_submodules.py --shallow --platform nrfconnect
+
+> **Note**:
+>
+> For Linux operating system install
+> [SEGGER J-Link Software](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack).
+
+### Install Command Line Tools
+
+With admin permissions enabled, download and install the
+[nRF Command Line Tools](https://www.nordicsemi.com/Products/Development-tools/nrf-command-line-tools).
+
+### Install Toolchain Manager
+
+Toolchain Manager is available from
+[nRF Connect for Desktop](https://www.nordicsemi.com/Products/Development-tools/nrf-connect-for-desktop),
+a cross-platform tool that provides different applications that simplify
+installing the nRF Connect SDK. Both the tool and the application are available
+for Windows, Linux, and macOS.
+
+To install the Toolchain Manager app, complete the following steps:
+
+1. [Download nRF Connect for Desktop](https://www.nordicsemi.com/Products/Development-tools/nrf-connect-for-desktop/download#infotabs)
+ for your operating system.
+
+2. Install and run the tool on your machine.
+
+3. In the **APPS** section, click **Install** button on the Toolchain Manager
+ tab.
+
+### Install nRF Connect SDK
+
+Complete the following steps to install the nRF Connect SDK:
+
+1. Open Toolchain Manager in nRF Connect for Desktop.
+
+2. Click the **Install** button next to the
+ [recommended](../../../config/nrfconnect/.nrfconnect-recommended-revision)
+ version of the nRF Connect SDK.
+
+3. A pop-up window will inform you about the current installation directory. If
+ you want to change the directory, click the **Change directory** button.
+ Otherwise, click the **Continue installation** button.
+
+4. When the nRF Connect SDK is installed on your machine, the **Install**
+ button changes to the **Open VS Code** button.
+
+5. Click the dropdown menu next to the **Open VS Code** button for the
+ installed nRF Connect SDK version, and select **Open terminal**.
+
+6. Make sure that the nRF Connect SDK version is compatible with the Matter SDK
+ version:
+
+ ```
+ $ cd {connectedhomeip directory}
+ $ python3 scripts/setup/nrfconnect/update_ncs.py --update
+ ```
+
+Now you can proceed with the [Building](#building) instruction.
+
+<hr>
+
+## Building
+
+Complete the following steps to build the sample:
+
+1. Navigate to the example's directory:
+
+ ```
+ $ cd examples/lighting-app/nrfconnect
+ ```
+
+2. Run the following command to build the example, with _build-target_ replaced
+ with the build target name of the Nordic Semiconductor's kit you own, for
+ example `nrf52840dk/nrf52840`:
+
+ ```
+ $ west build -b build-target --sysbuild
+ ```
+
+ You only need to specify the build target on the first build. See
+ [Requirements](#requirements) for the build target names of compatible kits.
+
+The output `zephyr.hex` file will be available in the `build/nrfconnect/zephyr/`
+directory.
+
+### Removing build artifacts
+
+If you're planning to build the example for a different kit or make changes to
+the configuration, remove all build artifacts before building. To do so, use the
+following command:
+
+ ```
+ $ rm -r build
+ ```
+
+### Building with release configuration
+
+To build the example with release configuration that disables the diagnostic
+features like logs and command-line interface, run the following command:
+
+ ```
+ $ west build -b build-target --sysbuild -- -DFILE_SUFFIX=release
+ ```
+
+Remember to replace _build-target_ with the build target name of the Nordic
+Semiconductor's kit you own.
+
+### Building with Pigweed RPCs
+
+The RPCs in `lighting-common/lighting_service/lighting_service.proto` can be
+used to control various functionalities of the lighting app from a USB-connected
+host computer. To build the example with the RPC server, run the following
+command with _build-target_ replaced with the build target name of the Nordic
+Semiconductor's kit you own:
+
+ ```
+ $ west build -b build-target --sysbuild -- -DOVERLAY_CONFIG=rpc.overlay
+ ```
+
+### Building with Device Firmware Upgrade support
+
+Support for DFU using Matter OTA is enabled by default.
+
+To enable DFU over Bluetooth LE, run the following command with _build-target_
+replaced with the build target name of the Nordic Semiconductor kit you are
+using (for example `nrf52840dk/nrf52840`):
+
+ ```
+ $ west build -b build-target --sysbuild -- -DCONFIG_CHIP_DFU_OVER_BT_SMP=y
+ ```
+
+> **Note**:
+>
+> There are two types of Device Firmware Upgrade modes: single-image DFU and
+> multi-image DFU. Single-image mode supports upgrading only one firmware image,
+> the application image, and should be used for single-core nRF52840 DK devices.
+> Multi-image mode allows to upgrade more firmware images and is suitable for
+> upgrading the application core and network core firmware in two-core nRF5340
+> DK devices.
+>
+> Currently the multi-image mode is only available for the DFU over Bluetooth LE
+> method.
+
+#### Changing bootloader configuration
+
+To change the default MCUboot configuration, edit the `prj.conf` file located in
+the `sysbuild/mcuboot` directory.
+
+Make sure to keep the configuration consistent with changes made to the
+application configuration. This is necessary for the configuration to work, as
+the bootloader image is a separate application from the user application and it
+has its own configuration file.
+
+#### Changing flash memory settings
+
+In the default configuration, the MCUboot uses the
+[Partition Manager](https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/scripts/partition_manager/partition_manager.html#partition-manager)
+to configure flash partitions used for the bootloader application image slot
+purposes. You can change these settings by defining
+[static partitions](https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/scripts/partition_manager/partition_manager.html#ug-pm-static).
+This example uses this option to define using an external flash.
+
+To modify the flash settings of your board (that is, your _build-target_, for
+example `nrf52840dk/nrf52840`), edit the `pm_static_<build_target>.yml` file
+(for example `pm_static_nrf52840dk_nrf52840.yml`), located in the main
+application directory.
+
+<hr>
+
+## Configuring the example
+
+The Zephyr ecosystem is based on Kconfig files and the settings can be modified
+using the menuconfig utility.
+
+To open the menuconfig utility, run the following command from the example
+directory:
+
+ ```
+ $ west build -b build-target --sysbuild -t menuconfig
+ ```
+
+Remember to replace _build-target_ with the build target name of the Nordic
+Semiconductor's kit you own.
+
+Changes done with menuconfig will be lost if the `build` directory is deleted.
+To make them persistent, save the configuration options in the `prj.conf` file.
+
+### Example build types
+
+The example uses different configuration files depending on the supported
+features. Configuration files are provided for different build types and they
+are located in the application root directory.
+
+The `prj.conf` file represents a debug build type. Other build types are covered
+by dedicated files with the build type added as a suffix to the prj part, as per
+the following list. For example, the release build type file name is
+`prj_release.conf`. If a board has other configuration files, for example
+associated with partition layout or child image configuration, these follow the
+same pattern.
+
+Before you start testing the application, you can select one of the build types
+supported by the sample. This sample supports the following build types,
+depending on the selected board:
+
+- debug -- Debug version of the application - can be used to enable additional
+ features for verifying the application behavior, such as logs or
+ command-line shell. It can be used only for the nRF52840 DK and nRF5340 DK,
+ as those platforms have DFU enabled by default.
+- release -- Release version of the application - can be used to enable only
+ the necessary application functionalities to optimize its performance. It
+ can be used only for the nRF52840 DK and nRF5340 DK, as those platforms have
+ DFU enabled by default.
+
+For more information, see the
+[Configuring nRF Connect SDK examples](../../../docs/platforms/nrf/nrfconnect_examples_configuration.md)
+page.
+
+<hr>
+
+## Flashing and debugging
+
+The flashing and debugging procedure is different for the development kits and
+the nRF52840 Dongle.
+
+### Flashing on the development kits
+
+To flash the application to the device, use the west tool and run the following
+command from the example directory:
+
+ ```
+ $ west flash --erase
+ ```
+
+If you have multiple development kits connected, west will prompt you to pick
+the correct one.
+
+To debug the application on target, run the following command from the example
+directory:
+
+ ```
+ $ west debug
+ ```
+
+### Flashing on the nRF52840 Dongle
+
+Visit
+[Programming and Debugging nRF52840 Dongle](https://docs.zephyrproject.org/latest/boards/arm/nrf52840dongle_nrf52840/doc/index.html#programming-and-debugging)
+to read more about flashing on the nRF52840 Dongle.
+
+<hr>
+
+## Testing the example
+
+Check the [CLI tutorial](../../../docs/platforms/nrf/nrfconnect_examples_cli.md)
+to learn how to use command-line interface of the application.
+
+### Testing using Linux CHIPTool
+
+Read the
+[CHIP Tool user guide](../../../docs/development_controllers/chip-tool/chip_tool_guide.md)
+to see how to use [CHIP Tool for Linux or mac OS](../../chip-tool/README.md) to
+commission and control the application within a Matter-enabled Thread network.
+
+### Testing using Android CHIPTool
+
+Read the
+[Android commissioning guide](../../../docs/platforms/nrf/nrfconnect_android_commissioning.md)
+to see how to use [CHIPTool](../../../examples/android/CHIPTool/README.md) for
+Android smartphones to commission and control the application within a
+Matter-enabled Thread network.
+
+### Testing Device Firmware Upgrade
+
+Read the
+[DFU tutorial](../../../docs/platforms/nrf/nrfconnect_examples_software_update.md)
+to see how to upgrade your device firmware.
+
+## Testing using the RPC console
+
+If the flashed device has been built with the pigweed RPCs, the RPC console can
+be used to interact with the device.
+
+Build or install the [rpc console](../../common/pigweed/rpc_console/README.md)
+
+Start the console
+
+ ```
+ $ chip-console --device /dev/ttyUSB0
+ ```
+
+From within the console you can then invoke rpcs:
+
+ ```python
+ rpcs.chip.rpc.Lighting.Get()
+
+ rpcs.chip.rpc.Lighting.Set(on=True, level=128, color=protos.chip.rpc.LightingColor(hue=5, saturation=5))
+ ```
+
+## Device Tracing
+
+Device tracing is available to analyze the device performance. To turn on
+tracing, build with RPC enabled. See
+[Using the RPC console](#building-with-pigweed-rpcs).
+
+Obtain tracing json file.
+
+```
+ $ ./{PIGWEED_REPO}/pw_trace_tokenized/py/pw_trace_tokenized/get_trace.py -d {PORT} -o {OUTPUT_FILE} \
+ -t {ELF_FILE} {PIGWEED_REPO}/pw_trace_tokenized/pw_trace_protos/trace_rpc.proto
+```
diff --git a/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dk_nrf52840.overlay b/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dk_nrf52840.overlay
new file mode 100644
index 00000000000000..96f955afe880cf
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dk_nrf52840.overlay
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/ {
+ chosen {
+ nordic,pm-ext-flash = &mx25r64;
+ };
+
+ /*
+ * In some default configurations within the nRF Connect SDK,
+ * e.g. on nRF52840, the chosen zephyr,entropy node is &cryptocell.
+ * This devicetree overlay ensures that default is overridden wherever it
+ * is set, as this application uses the RNG node for entropy exclusively.
+ */
+
+ chosen {
+ zephyr,entropy = &rng;
+ };
+
+ /*
+ * By default, PWM module is only configured for led0 (LED1 on the board).
+ * The lighting-app, however, uses LED2 to show the state of the lighting,
+ * including its brightness level.
+ */
+ aliases {
+ pwm-led1 = &pwm_led1;
+ };
+
+ pwmleds {
+ pwm_led1: pwm_led_1 {
+ pwms = <&pwm0 1 PWM_MSEC(20) PWM_POLARITY_INVERTED>;
+ };
+ };
+
+};
+
+&pwm0 {
+ pinctrl-0 = <&pwm0_default_alt>;
+ pinctrl-1 = <&pwm0_sleep_alt>;
+ pinctrl-names = "default", "sleep";
+};
+
+&pinctrl {
+ pwm0_default_alt: pwm0_default_alt {
+ group1 {
+ psels = <NRF_PSEL(PWM_OUT1, 0, 14)>;
+ nordic,invert;
+ };
+ };
+
+ pwm0_sleep_alt: pwm0_sleep_alt {
+ group1 {
+ psels = <NRF_PSEL(PWM_OUT1, 0, 14)>;
+ low-power-enable;
+ };
+ };
+
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dongle_nrf52840.conf b/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dongle_nrf52840.conf
new file mode 100644
index 00000000000000..db5151dc6c7ef4
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dongle_nrf52840.conf
@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2022 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Configure logging over USB
+# - do enable shell to reduce flash usage
+# - disable CDC ACM logs as it may lead to infinite loop when CDC ACM is used as the log backend
+CONFIG_USB_DEVICE_STACK=y
+CONFIG_CONSOLE=y
+CONFIG_UART_CONSOLE=y
+CONFIG_LOG_BACKEND_UART=y
+CONFIG_SHELL_LOG_BACKEND=n
+CONFIG_UART_LINE_CTRL=y
+CONFIG_USB_CDC_ACM_LOG_LEVEL_OFF=y
+
+# The minimal logging mode does not work properly with the USB CDC device, so use the deferred mode
+CONFIG_LOG_MODE_MINIMAL=n
+CONFIG_LOG_MODE_DEFERRED=y
+CONFIG_LOG_BUFFER_SIZE=8192
+
+# Reduce the code size as the dongle reserves some space for MBR and Open Bootloader
+CONFIG_ASSERT_VERBOSE=n
+CONFIG_SHELL=n
+CONFIG_OPENTHREAD_SHELL=n
+
+# Use partition manager to configure the settings partition not to overlap with Open Bootloader
+CONFIG_PM_SINGLE_IMAGE=y
+
+# Disable factory data support.
+CONFIG_CHIP_FACTORY_DATA=n
+CONFIG_CHIP_FACTORY_DATA_BUILD=n
+
+# Disable Matter OTA DFU
+CONFIG_CHIP_OTA_REQUESTOR=n
+
+# Disable QSPI NOR
+CONFIG_CHIP_QSPI_NOR=n
diff --git a/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dongle_nrf52840.overlay b/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dongle_nrf52840.overlay
new file mode 100644
index 00000000000000..b9290884c459f3
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/boards/nrf52840dongle_nrf52840.overlay
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2021 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http: //www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ / {
+ chosen {
+ zephyr,console = &cdc_acm_uart0;
+ };
+};
+
+&zephyr_udc0 {
+ cdc_acm_uart0: cdc_acm_uart0 {
+ compatible = "zephyr,cdc-acm-uart";
+ label = "CDC_ACM_0";
+ };
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/boards/nrf5340dk_nrf5340_cpuapp.overlay b/examples/manufacturer-specific-app/nrfconnect/boards/nrf5340dk_nrf5340_cpuapp.overlay
new file mode 100644
index 00000000000000..3a80c7a3552b7a
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/boards/nrf5340dk_nrf5340_cpuapp.overlay
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2021 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zephyr/dt-bindings/ipc_service/static_vrings.h>
+
+/ {
+ chosen {
+ nordic,pm-ext-flash = &mx25r64;
+ };
+
+ /*
+ * By default, PWM module is only configured for led0 (LED1 on the board).
+ * The lighting-app, however, uses LED2 to show the state of the lighting,
+ * including its brightness level.
+ */
+ aliases {
+ pwm-led1 = &pwm_led1;
+ };
+
+ pwmleds {
+ compatible = "pwm-leds";
+ pwm_led1: pwm_led_1 {
+ pwms = < &pwm0 1 PWM_MSEC(20) PWM_POLARITY_INVERTED>;
+ };
+ };
+};
+
+/* Set IPC thread priority to the highest value to not collide with other threads. */
+&ipc0 {
+ zephyr,priority = <0 PRIO_COOP>;
+};
+
+&pwm0 {
+ pinctrl-0 = <&pwm0_default_alt>;
+ pinctrl-1 = <&pwm0_sleep_alt>;
+ pinctrl-names = "default", "sleep";
+};
+
+&pinctrl {
+ pwm0_default_alt: pwm0_default_alt {
+ group1 {
+ psels = <NRF_PSEL(PWM_OUT1, 0, 29)>;
+ nordic,invert;
+ };
+ };
+
+ pwm0_sleep_alt: pwm0_sleep_alt {
+ group1 {
+ psels = <NRF_PSEL(PWM_OUT1, 0, 29)>;
+ low-power-enable;
+ };
+ };
+
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/boards/nrf7002dk_nrf5340_cpuapp.overlay b/examples/manufacturer-specific-app/nrfconnect/boards/nrf7002dk_nrf5340_cpuapp.overlay
new file mode 100644
index 00000000000000..2a8c6bb21f8c4b
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/boards/nrf7002dk_nrf5340_cpuapp.overlay
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zephyr/dt-bindings/ipc_service/static_vrings.h>
+
+/ {
+ chosen {
+ nordic,pm-ext-flash = &mx25r64;
+ };
+
+ /*
+ * By default, PWM module is only configured for led0 (LED1 on the board).
+ * The light bulb app, however, uses LED2 to show the state of the lighting,
+ * including its brightness level.
+ */
+ aliases {
+ pwm-led1 = &pwm_led1;
+ };
+
+ pwmleds {
+ compatible = "pwm-leds";
+ pwm_led1: pwm_led_1 {
+ pwms = < &pwm0 1 PWM_MSEC(20) PWM_POLARITY_NORMAL>;
+ };
+ };
+};
+
+/* Set IPC thread priority to the highest value to not collide with other threads. */
+&ipc0 {
+ zephyr,priority = <0 PRIO_COOP>;
+};
+
+&pwm0 {
+ pinctrl-0 = <&pwm0_default_alt>;
+ pinctrl-1 = <&pwm0_sleep_alt>;
+ pinctrl-names = "default", "sleep";
+};
+
+&pinctrl {
+ pwm0_default_alt: pwm0_default_alt {
+ group1 {
+ psels = <NRF_PSEL(PWM_OUT1, 1, 7)>;
+ nordic,invert;
+ };
+ };
+
+ pwm0_sleep_alt: pwm0_sleep_alt {
+ group1 {
+ psels = <NRF_PSEL(PWM_OUT1, 1, 7)>;
+ low-power-enable;
+ };
+ };
+
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/AppTask.cpp b/examples/manufacturer-specific-app/nrfconnect/main/AppTask.cpp
new file mode 100644
index 00000000000000..754b8db0b5d892
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/AppTask.cpp
@@ -0,0 +1,739 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "AppTask.h"
+
+#include "AppConfig.h"
+#include "AppEvent.h"
+#include "FabricTableDelegate.h"
+#include "LEDUtil.h"
+#include "PWMDevice.h"
+
+#include <DeviceInfoProviderImpl.h>
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app/TestEventTriggerDelegate.h>
+#include <app/clusters/identify-server/identify-server.h>
+#include <app/clusters/ota-requestor/OTATestEventTriggerHandler.h>
+#include <app/server/Dnssd.h>
+#include <app/server/OnboardingCodesUtil.h>
+#include <app/server/Server.h>
+#include <app/util/persistence/DefaultAttributePersistenceProvider.h>
+#include <app/util/persistence/DeferredAttributePersistenceProvider.h>
+#include <credentials/DeviceAttestationCredsProvider.h>
+#include <credentials/examples/DeviceAttestationCredsExample.h>
+#include <data-model-providers/codegen/Instance.h>
+#include <lib/core/ErrorStr.h>
+#include <lib/support/CHIPMem.h>
+#include <lib/support/CodeUtils.h>
+#include <system/SystemClock.h>
+
+#ifdef CONFIG_CHIP_WIFI
+#include <app/clusters/network-commissioning/network-commissioning.h>
+#include <platform/nrfconnect/wifi/NrfWiFiDriver.h>
+#endif
+
+#if CONFIG_CHIP_OTA_REQUESTOR
+#include "OTAUtil.h"
+#endif
+
+#ifdef CONFIG_CHIP_CRYPTO_PSA
+#include <crypto/PSAOperationalKeystore.h>
+#ifdef CONFIG_CHIP_MIGRATE_OPERATIONAL_KEYS_TO_ITS
+#include "MigrationManager.h"
+#endif
+#endif
+
+#include <dk_buttons_and_leds.h>
+#include <zephyr/kernel.h>
+#include <zephyr/logging/log.h>
+
+LOG_MODULE_DECLARE(app, CONFIG_CHIP_APP_LOG_LEVEL);
+
+using namespace ::chip;
+using namespace ::chip::app;
+using namespace ::chip::Credentials;
+using namespace ::chip::DeviceLayer;
+
+namespace {
+
+constexpr int kFactoryResetTriggerTimeout = 3000;
+constexpr int kFactoryResetCancelWindowTimeout = 3000;
+constexpr int kAppEventQueueSize = 10;
+constexpr EndpointId kLightEndpointId = 1;
+constexpr uint8_t kDefaultMinLevel = 0;
+constexpr uint8_t kDefaultMaxLevel = 254;
+#if NUMBER_OF_BUTTONS == 2
+constexpr uint32_t kAdvertisingTriggerTimeout = 3000;
+#endif
+
+// NOTE! This key is for test/certification only and should not be available in production devices!
+// If CONFIG_CHIP_FACTORY_DATA is enabled, this value is read from the factory data.
+uint8_t sTestEventTriggerEnableKey[TestEventTriggerDelegate::kEnableKeyLength] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
+
+K_MSGQ_DEFINE(sAppEventQueue, sizeof(AppEvent), kAppEventQueueSize, alignof(AppEvent));
+k_timer sFunctionTimer;
+
+Identify sIdentify = { kLightEndpointId, AppTask::IdentifyStartHandler, AppTask::IdentifyStopHandler,
+ Clusters::Identify::IdentifyTypeEnum::kVisibleIndicator };
+
+LEDWidget sStatusLED;
+LEDWidget sIdentifyLED;
+#if NUMBER_OF_LEDS == 4
+FactoryResetLEDsWrapper<2> sFactoryResetLEDs{ { FACTORY_RESET_SIGNAL_LED, FACTORY_RESET_SIGNAL_LED1 } };
+#endif
+
+bool sIsNetworkProvisioned = false;
+bool sIsNetworkEnabled = false;
+bool sHaveBLEConnections = false;
+
+const struct pwm_dt_spec sLightPwmDevice = PWM_DT_SPEC_GET(DT_ALIAS(pwm_led1));
+
+chip::DeviceLayer::DeviceInfoProviderImpl gExampleDeviceInfoProvider;
+
+// Define a custom attribute persister which makes actual write of the CurrentLevel attribute value
+// to the non-volatile storage only when it has remained constant for 5 seconds. This is to reduce
+// the flash wearout when the attribute changes frequently as a result of MoveToLevel command.
+// DeferredAttribute object describes a deferred attribute, but also holds a buffer with a value to
+// be written, so it must live so long as the DeferredAttributePersistenceProvider object.
+DeferredAttribute gCurrentLevelPersister(ConcreteAttributePath(kLightEndpointId, Clusters::LevelControl::Id,
+ Clusters::LevelControl::Attributes::CurrentLevel::Id));
+
+// Deferred persistence will be auto-initialized as soon as the default persistence is initialized
+DefaultAttributePersistenceProvider gSimpleAttributePersistence;
+DeferredAttributePersistenceProvider gDeferredAttributePersister(gSimpleAttributePersistence,
+ Span<DeferredAttribute>(&gCurrentLevelPersister, 1),
+ System::Clock::Milliseconds32(5000));
+
+#ifdef CONFIG_CHIP_CRYPTO_PSA
+chip::Crypto::PSAOperationalKeystore sPSAOperationalKeystore{};
+#endif
+} // namespace
+
+namespace LedConsts {
+constexpr uint32_t kBlinkRate_ms{ 500 };
+constexpr uint32_t kIdentifyBlinkRate_ms{ 500 };
+
+namespace StatusLed {
+namespace Unprovisioned {
+constexpr uint32_t kOn_ms{ 100 };
+constexpr uint32_t kOff_ms{ kOn_ms };
+} /* namespace Unprovisioned */
+namespace Provisioned {
+constexpr uint32_t kOn_ms{ 50 };
+constexpr uint32_t kOff_ms{ 950 };
+} /* namespace Provisioned */
+
+} /* namespace StatusLed */
+} /* namespace LedConsts */
+
+#ifdef CONFIG_CHIP_WIFI
+app::Clusters::NetworkCommissioning::Instance sWiFiCommissioningInstance(0, &(NetworkCommissioning::NrfWiFiDriver::Instance()));
+#endif
+
+CHIP_ERROR AppTask::Init()
+{
+ // Initialize CHIP stack
+ LOG_INF("Init CHIP stack");
+
+ CHIP_ERROR err = chip::Platform::MemoryInit();
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("Platform::MemoryInit() failed");
+ return err;
+ }
+
+ err = PlatformMgr().InitChipStack();
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("PlatformMgr().InitChipStack() failed");
+ return err;
+ }
+
+#if defined(CONFIG_NET_L2_OPENTHREAD)
+ err = ThreadStackMgr().InitThreadStack();
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("ThreadStackMgr().InitThreadStack() failed");
+ return err;
+ }
+
+#if CONFIG_CHIP_THREAD_SSED
+ err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_SynchronizedSleepyEndDevice);
+#elif CONFIG_OPENTHREAD_MTD_SED
+ err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_SleepyEndDevice);
+#else
+ err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_Router);
+#endif
+
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("ConnectivityMgr().SetThreadDeviceType() failed");
+ return err;
+ }
+#elif defined(CONFIG_CHIP_WIFI)
+ sWiFiCommissioningInstance.Init();
+#else
+ return CHIP_ERROR_INTERNAL;
+#endif // CONFIG_NET_L2_OPENTHREAD
+
+ // Initialize LEDs
+ LEDWidget::InitGpio();
+ LEDWidget::SetStateUpdateCallback(LEDStateUpdateHandler);
+
+ sStatusLED.Init(SYSTEM_STATE_LED);
+ sIdentifyLED.Init(LIGHTING_STATE_LED);
+ sIdentifyLED.Set(false);
+
+ UpdateStatusLED();
+
+ // Initialize buttons
+ int ret = dk_buttons_init(ButtonEventHandler);
+ if (ret)
+ {
+ LOG_ERR("dk_buttons_init() failed");
+ return chip::System::MapErrorZephyr(ret);
+ }
+
+ // Initialize function button timer
+ k_timer_init(&sFunctionTimer, &AppTask::FunctionTimerTimeoutCallback, nullptr);
+ k_timer_user_data_set(&sFunctionTimer, this);
+
+#ifdef CONFIG_MCUMGR_TRANSPORT_BT
+ // Initialize DFU over SMP
+ GetDFUOverSMP().Init();
+ GetDFUOverSMP().ConfirmNewImage();
+#endif
+
+#ifdef CONFIG_CHIP_OTA_REQUESTOR
+ /* OTA image confirmation must be done before the factory data init. */
+ OtaConfirmNewImage();
+#endif
+
+ // Initialize lighting device (PWM)
+ uint8_t minLightLevel = kDefaultMinLevel;
+ Clusters::LevelControl::Attributes::MinLevel::Get(kLightEndpointId, &minLightLevel);
+
+ uint8_t maxLightLevel = kDefaultMaxLevel;
+ Clusters::LevelControl::Attributes::MaxLevel::Get(kLightEndpointId, &maxLightLevel);
+
+ ret = mPWMDevice.Init(&sLightPwmDevice, minLightLevel, maxLightLevel, maxLightLevel);
+ if (ret != 0)
+ {
+ return chip::System::MapErrorZephyr(ret);
+ }
+ mPWMDevice.SetCallbacks(ActionInitiated, ActionCompleted);
+
+ // Initialize CHIP server
+#if CONFIG_CHIP_FACTORY_DATA
+ ReturnErrorOnFailure(mFactoryDataProvider.Init());
+ SetDeviceInstanceInfoProvider(&mFactoryDataProvider);
+ SetDeviceAttestationCredentialsProvider(&mFactoryDataProvider);
+ SetCommissionableDataProvider(&mFactoryDataProvider);
+ // Read EnableKey from the factory data.
+ MutableByteSpan enableKey(sTestEventTriggerEnableKey);
+ err = mFactoryDataProvider.GetEnableKey(enableKey);
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("mFactoryDataProvider.GetEnableKey() failed. Could not delegate a test event trigger");
+ memset(sTestEventTriggerEnableKey, 0, sizeof(sTestEventTriggerEnableKey));
+ }
+#else
+ SetDeviceInstanceInfoProvider(&DeviceInstanceInfoProviderMgrImpl());
+ SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider());
+#endif
+
+ static CommonCaseDeviceServerInitParams initParams;
+ static SimpleTestEventTriggerDelegate sTestEventTriggerDelegate{};
+ static OTATestEventTriggerHandler sOtaTestEventTriggerHandler{};
+ VerifyOrDie(sTestEventTriggerDelegate.Init(ByteSpan(sTestEventTriggerEnableKey)) == CHIP_NO_ERROR);
+ VerifyOrDie(sTestEventTriggerDelegate.AddHandler(&sOtaTestEventTriggerHandler) == CHIP_NO_ERROR);
+#ifdef CONFIG_CHIP_CRYPTO_PSA
+ initParams.operationalKeystore = &sPSAOperationalKeystore;
+#endif
+ (void) initParams.InitializeStaticResourcesBeforeServerInit();
+ VerifyOrDie(gSimpleAttributePersistence.Init(initParams.persistentStorageDelegate) == CHIP_NO_ERROR);
+
+ initParams.dataModelProvider = CodegenDataModelProviderInstance(initParams.persistentStorageDelegate);
+ initParams.testEventTriggerDelegate = &sTestEventTriggerDelegate;
+ ReturnErrorOnFailure(chip::Server::GetInstance().Init(initParams));
+ AppFabricTableDelegate::Init();
+
+#ifdef CONFIG_CHIP_MIGRATE_OPERATIONAL_KEYS_TO_ITS
+ err = MoveOperationalKeysFromKvsToIts(sLocalInitData.mServerInitParams->persistentStorageDelegate,
+ sLocalInitData.mServerInitParams->operationalKeystore);
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("MoveOperationalKeysFromKvsToIts() failed");
+ return err;
+ }
+#endif
+
+ gExampleDeviceInfoProvider.SetStorageDelegate(&Server::GetInstance().GetPersistentStorage());
+ chip::DeviceLayer::SetDeviceInfoProvider(&gExampleDeviceInfoProvider);
+ app::SetAttributePersistenceProvider(&gDeferredAttributePersister);
+
+ ConfigurationMgr().LogDeviceConfig();
+ PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE));
+
+ // Add CHIP event handler and start CHIP thread.
+ // Note that all the initialization code should happen prior to this point to avoid data races
+ // between the main and the CHIP threads.
+ PlatformMgr().AddEventHandler(ChipEventHandler, 0);
+
+ err = PlatformMgr().StartEventLoopTask();
+ if (err != CHIP_NO_ERROR)
+ {
+ LOG_ERR("PlatformMgr().StartEventLoopTask() failed");
+ }
+
+ return err;
+}
+
+CHIP_ERROR AppTask::StartApp()
+{
+ ReturnErrorOnFailure(Init());
+
+ AppEvent event = {};
+
+ while (true)
+ {
+ k_msgq_get(&sAppEventQueue, &event, K_FOREVER);
+ DispatchEvent(event);
+ }
+
+ return CHIP_NO_ERROR;
+}
+
+void AppTask::IdentifyStartHandler(Identify *)
+{
+ AppEvent event;
+ event.Type = AppEventType::IdentifyStart;
+ event.Handler = [](const AppEvent &) {
+ Instance().mPWMDevice.SuppressOutput();
+ sIdentifyLED.Blink(LedConsts::kIdentifyBlinkRate_ms);
+ };
+ PostEvent(event);
+}
+
+void AppTask::IdentifyStopHandler(Identify *)
+{
+ AppEvent event;
+ event.Type = AppEventType::IdentifyStop;
+ event.Handler = [](const AppEvent &) {
+ sIdentifyLED.Set(false);
+ Instance().mPWMDevice.ApplyLevel();
+ };
+ PostEvent(event);
+}
+
+#if NUMBER_OF_BUTTONS == 2
+void AppTask::StartBLEAdvertisementAndLightActionEventHandler(const AppEvent & event)
+{
+ if (event.ButtonEvent.Action == static_cast<uint8_t>(AppEventType::ButtonPushed))
+ {
+ Instance().StartTimer(kAdvertisingTriggerTimeout);
+ Instance().mFunction = FunctionEvent::AdvertisingStart;
+ }
+ else
+ {
+ if (Instance().mFunction == FunctionEvent::AdvertisingStart && Instance().mFunctionTimerActive)
+ {
+ Instance().CancelTimer();
+ Instance().mFunction = FunctionEvent::NoneSelected;
+
+ AppEvent button_event;
+ button_event.Type = AppEventType::Button;
+ button_event.ButtonEvent.PinNo = BLE_ADVERTISEMENT_START_AND_LIGHTING_BUTTON;
+ button_event.ButtonEvent.Action = static_cast<uint8_t>(AppEventType::ButtonReleased);
+ button_event.Handler = LightingActionEventHandler;
+ PostEvent(button_event);
+ }
+ }
+}
+#endif
+
+void AppTask::LightingActionEventHandler(const AppEvent & event)
+{
+ PWMDevice::Action_t action = PWMDevice::INVALID_ACTION;
+ int32_t actor = 0;
+
+ if (event.Type == AppEventType::Lighting)
+ {
+ action = static_cast<PWMDevice::Action_t>(event.LightingEvent.Action);
+ actor = event.LightingEvent.Actor;
+ }
+ else if (event.Type == AppEventType::Button)
+ {
+ action = Instance().mPWMDevice.IsTurnedOn() ? PWMDevice::OFF_ACTION : PWMDevice::ON_ACTION;
+ actor = static_cast<int32_t>(AppEventType::Button);
+ }
+
+ if (action != PWMDevice::INVALID_ACTION && Instance().mPWMDevice.InitiateAction(action, actor, NULL))
+ {
+ LOG_INF("Action is already in progress or active.");
+ }
+}
+
+void AppTask::ButtonEventHandler(uint32_t buttonState, uint32_t hasChanged)
+{
+ AppEvent button_event;
+ button_event.Type = AppEventType::Button;
+
+#if NUMBER_OF_BUTTONS == 2
+ if (BLE_ADVERTISEMENT_START_AND_LIGHTING_BUTTON_MASK & hasChanged)
+ {
+ button_event.ButtonEvent.PinNo = BLE_ADVERTISEMENT_START_AND_LIGHTING_BUTTON;
+ button_event.ButtonEvent.Action =
+ static_cast<uint8_t>((BLE_ADVERTISEMENT_START_AND_LIGHTING_BUTTON_MASK & buttonState) ? AppEventType::ButtonPushed
+ : AppEventType::ButtonReleased);
+ button_event.Handler = StartBLEAdvertisementAndLightActionEventHandler;
+ PostEvent(button_event);
+ }
+#else
+ if (LIGHTING_BUTTON_MASK & buttonState & hasChanged)
+ {
+ button_event.ButtonEvent.PinNo = LIGHTING_BUTTON;
+ button_event.ButtonEvent.Action = static_cast<uint8_t>(AppEventType::ButtonPushed);
+ button_event.Handler = LightingActionEventHandler;
+ PostEvent(button_event);
+ }
+
+ if (BLE_ADVERTISEMENT_START_BUTTON_MASK & buttonState & hasChanged)
+ {
+ button_event.ButtonEvent.PinNo = BLE_ADVERTISEMENT_START_BUTTON;
+ button_event.ButtonEvent.Action = static_cast<uint8_t>(AppEventType::ButtonPushed);
+ button_event.Handler = StartBLEAdvertisementHandler;
+ PostEvent(button_event);
+ }
+#endif
+
+ if (FUNCTION_BUTTON_MASK & hasChanged)
+ {
+ button_event.ButtonEvent.PinNo = FUNCTION_BUTTON;
+ button_event.ButtonEvent.Action =
+ static_cast<uint8_t>((FUNCTION_BUTTON_MASK & buttonState) ? AppEventType::ButtonPushed : AppEventType::ButtonReleased);
+ button_event.Handler = FunctionHandler;
+ PostEvent(button_event);
+ }
+}
+
+void AppTask::FunctionTimerTimeoutCallback(k_timer * timer)
+{
+ if (!timer)
+ {
+ return;
+ }
+
+ AppEvent event;
+ event.Type = AppEventType::Timer;
+ event.TimerEvent.Context = k_timer_user_data_get(timer);
+ event.Handler = FunctionTimerEventHandler;
+ PostEvent(event);
+}
+
+void AppTask::FunctionTimerEventHandler(const AppEvent & event)
+{
+ if (event.Type != AppEventType::Timer)
+ {
+ return;
+ }
+
+ // If we reached here, the button was held past kFactoryResetTriggerTimeout, initiate factory reset
+ if (Instance().mFunction == FunctionEvent::SoftwareUpdate)
+ {
+ LOG_INF("Factory Reset Triggered. Release button within %ums to cancel.", kFactoryResetTriggerTimeout);
+
+ // Start timer for kFactoryResetCancelWindowTimeout to allow user to cancel, if required.
+ Instance().StartTimer(kFactoryResetCancelWindowTimeout);
+ Instance().mFunction = FunctionEvent::FactoryReset;
+
+ // Turn off all LEDs before starting blink to make sure blink is co-ordinated.
+ sStatusLED.Set(false);
+#if NUMBER_OF_LEDS == 4
+ sFactoryResetLEDs.Set(false);
+#endif
+
+ sStatusLED.Blink(LedConsts::kBlinkRate_ms);
+#if NUMBER_OF_LEDS == 4
+ sFactoryResetLEDs.Blink(LedConsts::kBlinkRate_ms);
+#endif
+ }
+ else if (Instance().mFunction == FunctionEvent::FactoryReset)
+ {
+ // Actually trigger Factory Reset
+ Instance().mFunction = FunctionEvent::NoneSelected;
+ chip::Server::GetInstance().ScheduleFactoryReset();
+ }
+ else if (Instance().mFunction == FunctionEvent::AdvertisingStart)
+ {
+ // The button was held past kAdvertisingTriggerTimeout, start BLE advertisement if we have 2 buttons UI
+#if NUMBER_OF_BUTTONS == 2
+ StartBLEAdvertisementHandler(event);
+ Instance().mFunction = FunctionEvent::NoneSelected;
+#endif
+ }
+}
+
+void AppTask::FunctionHandler(const AppEvent & event)
+{
+ if (event.ButtonEvent.PinNo != FUNCTION_BUTTON)
+ return;
+
+ // To trigger software update: press the FUNCTION_BUTTON button briefly (< kFactoryResetTriggerTimeout)
+ // To initiate factory reset: press the FUNCTION_BUTTON for kFactoryResetTriggerTimeout + kFactoryResetCancelWindowTimeout
+ // All LEDs start blinking after kFactoryResetTriggerTimeout to signal factory reset has been initiated.
+ // To cancel factory reset: release the FUNCTION_BUTTON once all LEDs start blinking within the
+ // kFactoryResetCancelWindowTimeout
+ if (event.ButtonEvent.Action == static_cast<uint8_t>(AppEventType::ButtonPushed))
+ {
+ if (!Instance().mFunctionTimerActive && Instance().mFunction == FunctionEvent::NoneSelected)
+ {
+ Instance().StartTimer(kFactoryResetTriggerTimeout);
+ Instance().mFunction = FunctionEvent::SoftwareUpdate;
+ }
+ }
+ else
+ {
+ // If the button was released before factory reset got initiated, trigger a software update.
+ if (Instance().mFunctionTimerActive && Instance().mFunction == FunctionEvent::SoftwareUpdate)
+ {
+ Instance().CancelTimer();
+ Instance().mFunction = FunctionEvent::NoneSelected;
+
+#ifdef CONFIG_MCUMGR_TRANSPORT_BT
+ GetDFUOverSMP().StartServer();
+#else
+ LOG_INF("Software update is disabled");
+#endif
+ }
+ else if (Instance().mFunctionTimerActive && Instance().mFunction == FunctionEvent::FactoryReset)
+ {
+#if NUMBER_OF_LEDS == 4
+ sFactoryResetLEDs.Set(false);
+#endif
+ UpdateStatusLED();
+ Instance().CancelTimer();
+ Instance().mFunction = FunctionEvent::NoneSelected;
+ LOG_INF("Factory Reset has been Canceled");
+ }
+ }
+}
+
+void AppTask::StartBLEAdvertisementHandler(const AppEvent &)
+{
+ if (Server::GetInstance().GetFabricTable().FabricCount() != 0)
+ {
+ LOG_INF("Matter service BLE advertising not started - device is already commissioned");
+ return;
+ }
+
+ if (ConnectivityMgr().IsBLEAdvertisingEnabled())
+ {
+ LOG_INF("BLE advertising is already enabled");
+ return;
+ }
+
+ if (Server::GetInstance().GetCommissioningWindowManager().OpenBasicCommissioningWindow() != CHIP_NO_ERROR)
+ {
+ LOG_ERR("OpenBasicCommissioningWindow() failed");
+ }
+}
+
+void AppTask::UpdateLedStateEventHandler(const AppEvent & event)
+{
+ if (event.Type == AppEventType::UpdateLedState)
+ {
+ event.UpdateLedStateEvent.LedWidget->UpdateState();
+ }
+}
+
+void AppTask::LEDStateUpdateHandler(LEDWidget & ledWidget)
+{
+ AppEvent event;
+ event.Type = AppEventType::UpdateLedState;
+ event.Handler = UpdateLedStateEventHandler;
+ event.UpdateLedStateEvent.LedWidget = &ledWidget;
+ PostEvent(event);
+}
+
+void AppTask::UpdateStatusLED()
+{
+ // Update the status LED.
+ //
+ // If IPv6 network and service provisioned, keep the LED On constantly.
+ //
+ // If the system has ble connection(s) uptill the stage above, THEN blink the LED at an even
+ // rate of 100ms.
+ //
+ // Otherwise, blink the LED for a very short time.
+ if (sIsNetworkProvisioned && sIsNetworkEnabled)
+ {
+ sStatusLED.Set(true);
+ }
+ else if (sHaveBLEConnections)
+ {
+ sStatusLED.Blink(LedConsts::StatusLed::Unprovisioned::kOn_ms, LedConsts::StatusLed::Unprovisioned::kOff_ms);
+ }
+ else
+ {
+ sStatusLED.Blink(LedConsts::StatusLed::Provisioned::kOn_ms, LedConsts::StatusLed::Provisioned::kOff_ms);
+ }
+}
+
+void AppTask::ChipEventHandler(const ChipDeviceEvent * event, intptr_t /* arg */)
+{
+ switch (event->Type)
+ {
+ case DeviceEventType::kCHIPoBLEAdvertisingChange:
+#ifdef CONFIG_CHIP_NFC_COMMISSIONING
+ if (event->CHIPoBLEAdvertisingChange.Result == kActivity_Started)
+ {
+ if (NFCMgr().IsTagEmulationStarted())
+ {
+ LOG_INF("NFC Tag emulation is already started");
+ }
+ else
+ {
+ ShareQRCodeOverNFC(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE));
+ }
+ }
+ else if (event->CHIPoBLEAdvertisingChange.Result == kActivity_Stopped)
+ {
+ NFCMgr().StopTagEmulation();
+ }
+#endif
+ sHaveBLEConnections = ConnectivityMgr().NumBLEConnections() != 0;
+ UpdateStatusLED();
+ break;
+#if defined(CONFIG_NET_L2_OPENTHREAD)
+ case DeviceEventType::kDnssdInitialized:
+#if CONFIG_CHIP_OTA_REQUESTOR
+ InitBasicOTARequestor();
+#endif /* CONFIG_CHIP_OTA_REQUESTOR */
+ break;
+ case DeviceEventType::kThreadStateChange:
+ sIsNetworkProvisioned = ConnectivityMgr().IsThreadProvisioned();
+ sIsNetworkEnabled = ConnectivityMgr().IsThreadEnabled();
+#elif defined(CONFIG_CHIP_WIFI)
+ case DeviceEventType::kWiFiConnectivityChange:
+ sIsNetworkProvisioned = ConnectivityMgr().IsWiFiStationProvisioned();
+ sIsNetworkEnabled = ConnectivityMgr().IsWiFiStationEnabled();
+#if CONFIG_CHIP_OTA_REQUESTOR
+ if (event->WiFiConnectivityChange.Result == kConnectivity_Established)
+ {
+ InitBasicOTARequestor();
+ }
+#endif /* CONFIG_CHIP_OTA_REQUESTOR */
+#endif
+ UpdateStatusLED();
+ break;
+ default:
+ break;
+ }
+}
+void AppTask::CancelTimer()
+{
+ k_timer_stop(&sFunctionTimer);
+ mFunctionTimerActive = false;
+}
+
+void AppTask::StartTimer(uint32_t timeoutInMs)
+{
+ k_timer_start(&sFunctionTimer, K_MSEC(timeoutInMs), K_NO_WAIT);
+ mFunctionTimerActive = true;
+}
+
+void AppTask::ActionInitiated(PWMDevice::Action_t action, int32_t actor)
+{
+ if (action == PWMDevice::ON_ACTION)
+ {
+ LOG_INF("Turn On Action has been initiated");
+ }
+ else if (action == PWMDevice::OFF_ACTION)
+ {
+ LOG_INF("Turn Off Action has been initiated");
+ }
+ else if (action == PWMDevice::LEVEL_ACTION)
+ {
+ LOG_INF("Level Action has been initiated");
+ }
+}
+
+void AppTask::ActionCompleted(PWMDevice::Action_t action, int32_t actor)
+{
+ if (action == PWMDevice::ON_ACTION)
+ {
+ LOG_INF("Turn On Action has been completed");
+ }
+ else if (action == PWMDevice::OFF_ACTION)
+ {
+ LOG_INF("Turn Off Action has been completed");
+ }
+ else if (action == PWMDevice::LEVEL_ACTION)
+ {
+ LOG_INF("Level Action has been completed");
+ }
+
+ if (actor == static_cast<int32_t>(AppEventType::Button))
+ {
+ Instance().UpdateClusterState();
+ }
+}
+
+void AppTask::PostEvent(const AppEvent & event)
+{
+ if (k_msgq_put(&sAppEventQueue, &event, K_NO_WAIT) != 0)
+ {
+ LOG_INF("Failed to post event to app task event queue");
+ }
+}
+
+void AppTask::DispatchEvent(const AppEvent & event)
+{
+ if (event.Handler)
+ {
+ event.Handler(event);
+ }
+ else
+ {
+ LOG_INF("Event received with no handler. Dropping event.");
+ }
+}
+
+void AppTask::UpdateClusterState()
+{
+ SystemLayer().ScheduleLambda([this] {
+ // write the new on/off value
+ Protocols::InteractionModel::Status status =
+ Clusters::OnOff::Attributes::OnOff::Set(kLightEndpointId, mPWMDevice.IsTurnedOn());
+
+ if (status != Protocols::InteractionModel::Status::Success)
+ {
+ LOG_ERR("Updating on/off cluster failed: %x", to_underlying(status));
+ }
+
+ // write the current level
+ status = Clusters::LevelControl::Attributes::CurrentLevel::Set(kLightEndpointId, mPWMDevice.GetLevel());
+
+ if (status != Protocols::InteractionModel::Status::Success)
+ {
+ LOG_ERR("Updating level cluster failed: %x", to_underlying(status));
+ }
+ });
+}
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/ZclCallbacks.cpp b/examples/manufacturer-specific-app/nrfconnect/main/ZclCallbacks.cpp
new file mode 100644
index 00000000000000..b872a1c8416d49
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/ZclCallbacks.cpp
@@ -0,0 +1,90 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "AppTask.h"
+#include "PWMDevice.h"
+
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/ConcreteAttributePath.h>
+#include <lib/support/logging/CHIPLogging.h>
+
+using namespace chip;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::OnOff;
+
+void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t type, uint16_t size,
+ uint8_t * value)
+{
+ ClusterId clusterId = attributePath.mClusterId;
+ AttributeId attributeId = attributePath.mAttributeId;
+
+ if (clusterId == OnOff::Id && attributeId == OnOff::Attributes::OnOff::Id)
+ {
+ ChipLogProgress(Zcl, "Cluster OnOff: attribute OnOff set to %u", *value);
+ AppTask::Instance().GetPWMDevice().InitiateAction(*value ? PWMDevice::ON_ACTION : PWMDevice::OFF_ACTION,
+ static_cast<int32_t>(AppEventType::Lighting), value);
+ }
+ else if (clusterId == LevelControl::Id && attributeId == LevelControl::Attributes::CurrentLevel::Id)
+ {
+ ChipLogProgress(Zcl, "Cluster LevelControl: attribute CurrentLevel set to %u", *value);
+ if (AppTask::Instance().GetPWMDevice().IsTurnedOn())
+ {
+ AppTask::Instance().GetPWMDevice().InitiateAction(PWMDevice::LEVEL_ACTION, static_cast<int32_t>(AppEventType::Lighting),
+ value);
+ }
+ else
+ {
+ ChipLogDetail(Zcl, "LED is off. Try to use move-to-level-with-on-off instead of move-to-level");
+ }
+ }
+}
+
+/** @brief OnOff Cluster Init
+ *
+ * This function is called when a specific cluster is initialized. It gives the
+ * application an opportunity to take care of cluster initialization procedures.
+ * It is called exactly once for each endpoint where cluster is present.
+ *
+ * @param endpoint Ver.: always
+ *
+ * TODO Issue #3841
+ * emberAfOnOffClusterInitCallback happens before the stack initialize the cluster
+ * attributes to the default value.
+ * The logic here expects something similar to the deprecated Plugins callback
+ * emberAfPluginOnOffClusterServerPostInitCallback.
+ *
+ */
+void emberAfOnOffClusterInitCallback(EndpointId endpoint)
+{
+ Protocols::InteractionModel::Status status;
+ bool storedValue;
+
+ // Read storedValue on/off value
+ status = Attributes::OnOff::Get(endpoint, &storedValue);
+ if (status == Protocols::InteractionModel::Status::Success)
+ {
+ // Set actual state to the cluster state that was last persisted
+ AppTask::Instance().GetPWMDevice().InitiateAction(storedValue ? PWMDevice::ON_ACTION : PWMDevice::OFF_ACTION,
+ static_cast<int32_t>(AppEventType::Lighting),
+ reinterpret_cast<uint8_t *>(&storedValue));
+ }
+
+ AppTask::Instance().UpdateClusterState();
+}
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/include/AppConfig.h b/examples/manufacturer-specific-app/nrfconnect/main/include/AppConfig.h
new file mode 100644
index 00000000000000..3f311d4a8a45d3
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/include/AppConfig.h
@@ -0,0 +1,41 @@
+//
+// Copyright (c) 2020 Project CHIP Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+#include "BoardUtil.h"
+
+// ---- Lighting Example App Config ----
+
+#define FUNCTION_BUTTON DK_BTN1
+#define FUNCTION_BUTTON_MASK DK_BTN1_MSK
+
+#if NUMBER_OF_BUTTONS == 2
+#define BLE_ADVERTISEMENT_START_AND_LIGHTING_BUTTON DK_BTN2
+#define BLE_ADVERTISEMENT_START_AND_LIGHTING_BUTTON_MASK DK_BTN2_MSK
+#else
+#define LIGHTING_BUTTON DK_BTN2
+#define LIGHTING_BUTTON_MASK DK_BTN2_MSK
+#define BLE_ADVERTISEMENT_START_BUTTON DK_BTN4
+#define BLE_ADVERTISEMENT_START_BUTTON_MASK DK_BTN4_MSK
+#endif
+
+#define SYSTEM_STATE_LED DK_LED1
+#define LIGHTING_STATE_LED DK_LED2
+#if NUMBER_OF_LEDS == 4
+#define FACTORY_RESET_SIGNAL_LED DK_LED3
+#define FACTORY_RESET_SIGNAL_LED1 DK_LED4
+#endif
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/include/AppEvent.h b/examples/manufacturer-specific-app/nrfconnect/main/include/AppEvent.h
new file mode 100644
index 00000000000000..49c92cc03af5a6
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/include/AppEvent.h
@@ -0,0 +1,74 @@
+/*
+ *
+ * Copyright (c) 2018 Nest Labs, Inc.
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#include "EventTypes.h"
+
+class LEDWidget;
+
+enum class AppEventType : uint8_t
+{
+ None = 0,
+ Button,
+ ButtonPushed,
+ ButtonReleased,
+ Timer,
+ UpdateLedState,
+ Lighting,
+ IdentifyStart,
+ IdentifyStop,
+};
+
+enum class FunctionEvent : uint8_t
+{
+ NoneSelected = 0,
+ SoftwareUpdate = 0,
+ FactoryReset,
+ AdvertisingStart
+};
+
+struct AppEvent
+{
+ union
+ {
+ struct
+ {
+ uint8_t PinNo;
+ uint8_t Action;
+ } ButtonEvent;
+ struct
+ {
+ void * Context;
+ } TimerEvent;
+ struct
+ {
+ uint8_t Action;
+ int32_t Actor;
+ } LightingEvent;
+ struct
+ {
+ LEDWidget * LedWidget;
+ } UpdateLedStateEvent;
+ };
+
+ AppEventType Type{ AppEventType::None };
+ EventHandler Handler;
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/include/AppTask.h b/examples/manufacturer-specific-app/nrfconnect/main/include/AppTask.h
new file mode 100644
index 00000000000000..37be9a0334847c
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/include/AppTask.h
@@ -0,0 +1,98 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "AppEvent.h"
+#include "LEDWidget.h"
+#include "PWMDevice.h"
+
+#include <platform/CHIPDeviceLayer.h>
+
+#if CONFIG_CHIP_FACTORY_DATA
+#include <platform/nrfconnect/FactoryDataProvider.h>
+#else
+#include <platform/nrfconnect/DeviceInstanceInfoProviderImpl.h>
+#endif
+
+#ifdef CONFIG_CHIP_PW_RPC
+#include "Rpc.h"
+#endif
+
+#ifdef CONFIG_MCUMGR_TRANSPORT_BT
+#include "DFUOverSMP.h"
+#endif
+
+#include <cstdint>
+
+struct k_timer;
+struct Identify;
+
+class AppTask
+{
+public:
+ static AppTask & Instance()
+ {
+ static AppTask sAppTask;
+ return sAppTask;
+ };
+
+ CHIP_ERROR StartApp();
+
+ void UpdateClusterState();
+ PWMDevice & GetPWMDevice() { return mPWMDevice; }
+
+ static void IdentifyStartHandler(Identify *);
+ static void IdentifyStopHandler(Identify *);
+
+private:
+#ifdef CONFIG_CHIP_PW_RPC
+ friend class chip::rpc::NrfButton;
+#endif
+
+ CHIP_ERROR Init();
+
+ void CancelTimer();
+ void StartTimer(uint32_t timeoutInMs);
+
+ static void PostEvent(const AppEvent & event);
+ static void DispatchEvent(const AppEvent & event);
+ static void FunctionTimerEventHandler(const AppEvent & event);
+ static void LightingActionEventHandler(const AppEvent & event);
+ static void StartBLEAdvertisementHandler(const AppEvent & event);
+ static void UpdateLedStateEventHandler(const AppEvent & event);
+
+ static void ChipEventHandler(const chip::DeviceLayer::ChipDeviceEvent * event, intptr_t arg);
+ static void ButtonEventHandler(uint32_t buttonState, uint32_t hasChanged);
+ static void FunctionTimerTimeoutCallback(k_timer * timer);
+
+ static void ActionInitiated(PWMDevice::Action_t action, int32_t actor);
+ static void ActionCompleted(PWMDevice::Action_t action, int32_t actor);
+ static void UpdateStatusLED();
+ static void LEDStateUpdateHandler(LEDWidget & ledWidget);
+ static void FunctionHandler(const AppEvent & event);
+ static void StartBLEAdvertisementAndLightActionEventHandler(const AppEvent & event);
+
+ FunctionEvent mFunction = FunctionEvent::NoneSelected;
+ bool mFunctionTimerActive = false;
+ PWMDevice mPWMDevice;
+
+#if CONFIG_CHIP_FACTORY_DATA
+ chip::DeviceLayer::FactoryDataProvider<chip::DeviceLayer::InternalFlashFactoryData> mFactoryDataProvider;
+#endif
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/include/CHIPProjectConfig.h b/examples/manufacturer-specific-app/nrfconnect/main/include/CHIPProjectConfig.h
new file mode 100644
index 00000000000000..4baa186190f638
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/include/CHIPProjectConfig.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file
+ * Example project configuration file for CHIP.
+ *
+ * This is a place to put application or project-specific overrides
+ * to the default configuration values for general CHIP features.
+ *
+ */
+
+#pragma once
diff --git a/examples/manufacturer-specific-app/nrfconnect/main/main.cpp b/examples/manufacturer-specific-app/nrfconnect/main/main.cpp
new file mode 100644
index 00000000000000..2fa41047be0f82
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/main/main.cpp
@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright (c) 2020 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "AppTask.h"
+
+#include <system/SystemError.h>
+
+#include <zephyr/logging/log.h>
+
+#ifdef CONFIG_CHIP_PW_RPC
+#include "Rpc.h"
+#endif
+
+#if DT_NODE_HAS_COMPAT(DT_CHOSEN(zephyr_console), zephyr_cdc_acm_uart)
+#include <zephyr/drivers/uart.h>
+#include <zephyr/usb/usb_device.h>
+#endif
+
+LOG_MODULE_REGISTER(app, CONFIG_CHIP_APP_LOG_LEVEL);
+
+using namespace ::chip;
+
+#if DT_NODE_HAS_COMPAT(DT_CHOSEN(zephyr_console), zephyr_cdc_acm_uart)
+static int InitUSB()
+{
+ int err = usb_enable(nullptr);
+
+ if ((err != 0) && (err != -EALREADY))
+ {
+ LOG_ERR("Failed to initialize USB device %d", err);
+ return err;
+ }
+
+ const struct device * dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_console));
+ uint32_t dtr = 0;
+
+ while (!dtr)
+ {
+ uart_line_ctrl_get(dev, UART_LINE_CTRL_DTR, &dtr);
+ k_sleep(K_MSEC(100));
+ }
+
+ return 0;
+}
+#endif
+
+int main()
+{
+ CHIP_ERROR err = CHIP_NO_ERROR;
+
+#ifdef CONFIG_CHIP_PW_RPC
+ rpc::Init();
+#endif
+
+#if DT_NODE_HAS_COMPAT(DT_CHOSEN(zephyr_console), zephyr_cdc_acm_uart)
+ err = System::MapErrorZephyr(InitUSB());
+#endif
+
+ if (err == CHIP_NO_ERROR)
+ {
+ err = AppTask::Instance().StartApp();
+ }
+
+ LOG_ERR("Exited with code %" CHIP_ERROR_FORMAT, err.Format());
+ return err == CHIP_NO_ERROR ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/app-templates.json b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/app-templates.json
new file mode 100644
index 00000000000000..fc18a4b2963966
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/app-templates.json
@@ -0,0 +1,127 @@
+{
+ "name": "CHIP Application manufacturer-specific templates",
+ "version": "chip-v1",
+ "requiredFeatureLevel": 102,
+ "category": "matter",
+ "helpers": [
+ "partials/helper.js",
+ "common/ListHelper.js",
+ "common/StringHelper.js",
+ "common/ChipTypesHelper.js",
+ "common/attributes/Accessors.js",
+ "templates/app/helper.js",
+ "templates/chip/helper.js"
+ ],
+ "resources": {
+ "config-data": "config-data.yaml"
+ },
+ "override": "../../../../src/app/zap-templates/common/override.js",
+ "partials": [
+ {
+ "name": "header",
+ "path": "../../../../src/app/zap-templates/partials/header.zapt"
+ },
+ {
+ "name": "cluster_objects_struct",
+ "path": "../../../../src/app/zap-templates/partials/cluster-objects-struct.zapt"
+ },
+ {
+ "name": "cluster_enums_enum",
+ "path": "../../../../src/app/zap-templates/partials/cluster-enums-enum.zapt"
+ },
+ {
+ "name": "cluster_enums_ensure_known_value",
+ "path": "../../../../src/app/zap-templates/partials/cluster-enums-ensure-known-value.zapt"
+ },
+ {
+ "name": "cluster_objects_field_init",
+ "path": "../../../../src/app/zap-templates/partials/cluster-objects-field-init.zapt"
+ },
+ {
+ "name": "cluster_objects_attribute_typeinfo",
+ "path": "../../../../src/app/zap-templates/partials/cluster-objects-attribute-typeinfo.zapt"
+ }
+ ],
+ "templates": [
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/endpoint_config.zapt",
+ "name": "ZCL endpoint configuration",
+ "output": "endpoint_config.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/gen_config.zapt",
+ "name": "ZCL gen_config header",
+ "output": "gen_config.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/im-cluster-command-handler.zapt",
+ "name": "CHIP Client Callbacks for Interaction Model",
+ "output": "IMClusterCommandHandler.cpp"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/access.zapt",
+ "name": "Matter access definitions",
+ "output": "access.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/attribute-type.zapt",
+ "name": "ZCL attribute-type header",
+ "output": "attribute-type.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/callback.zapt",
+ "name": "ZCL callback header",
+ "output": "callback.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/attributes/Accessors.zapt",
+ "name": "Attributes Accessors header",
+ "output": "attributes/Accessors.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/attributes/Accessors-src.zapt",
+ "name": "Attributes Accessors",
+ "output": "attributes/Accessors.cpp"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/ids/Attributes.zapt",
+ "name": "Attributes Ids header",
+ "output": "ids/Attributes.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/ids/Clusters.zapt",
+ "name": "Clusters Ids header",
+ "output": "ids/Clusters.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/ids/Commands.zapt",
+ "name": "Commands Ids header",
+ "output": "ids/Commands.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/ids/Events.zapt",
+ "name": "Events Ids header",
+ "output": "ids/Events.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/cluster-objects.zapt",
+ "name": "Cluster objects header for Interaction Model",
+ "output": "cluster-objects.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/cluster-objects-src.zapt",
+ "name": "Cluster objects source for Interaction Model",
+ "output": "cluster-objects.cpp"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/cluster-enums.zapt",
+ "name": "Enum and bitmap header for clusters",
+ "output": "cluster-enums.h"
+ },
+ {
+ "path": "../../../../src/app/zap-templates/templates/app/cluster-enums-check.zapt",
+ "name": "Enum and bitmap method check header for clusters",
+ "output": "cluster-enums-check.h"
+ }
+ ]
+}
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/clusters/sample-external-manufacturer-specific-server.cpp b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/clusters/sample-external-manufacturer-specific-server.cpp
new file mode 100644
index 00000000000000..c5f0720a23feaf
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/clusters/sample-external-manufacturer-specific-server.cpp
@@ -0,0 +1,246 @@
+#include "sample-external-manufacturer-specific-server.h"
+
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Commands.h>
+#include <app/AttributeAccessInterfaceRegistry.h>
+#include <app/CommandHandler.h>
+#include <app/CommandHandlerInterfaceRegistry.h>
+#include <app/ConcreteCommandPath.h>
+#include <app/EventLogging.h>
+#include <app/reporting/reporting.h>
+#include <app/util/attribute-storage.h>
+#include <app/util/config.h>
+#include <app/util/util.h>
+#include <lib/support/CodeUtils.h>
+#include <lib/support/logging/CHIPLogging.h>
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::SampleExternalManufacturerSpecific;
+using namespace chip::app::Clusters::SampleExternalManufacturerSpecific::Commands;
+using namespace chip::app::Clusters::SampleExternalManufacturerSpecific::Attributes;
+
+// *****************************************************************************
+// Init/Shutdown Callbacks
+
+void MatterSampleExternalManufacturerSpecificPluginServerInitCallback()
+{
+ ChipLogProgress(Zcl, "Sample Manufacturer Specific Init. Ep %d, Total Ep %u",
+ MATTER_DM_SAMPLE_EXTERNAL_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_ENDPOINT_COUNT,
+ static_cast<uint16_t>(kNumSupportedEndpoints));
+ ReturnOnFailure(
+ CommandHandlerInterfaceRegistry::Instance().RegisterCommandHandler(&SampleExternalManufacturerSpecificServer::Instance()));
+ VerifyOrReturn(AttributeAccessInterfaceRegistry::Instance().Register(&SampleExternalManufacturerSpecificServer::Instance()),
+ CHIP_ERROR_INCORRECT_STATE);
+}
+
+void emberAfSampleExternalManufacturerSpecificClusterServerInitCallback(chip::EndpointId endpoint)
+{
+ ChipLogProgress(Zcl, "Creating Sample Manufacturer Specific cluster, Ep %d", endpoint);
+ SampleExternalManufacturerSpecificServer::Instance().RegisterEndpoint(endpoint);
+}
+
+void MatterSampleExternalManufacturerSpecificClusterServerShutdownCallback(chip::EndpointId endpoint)
+{
+ // There's currently no whole-cluster shutdown callback. That would trigger
+ // call to `Shutdown`. Thus ep-based shutdown calls `UnregisterEndpoint`
+ ChipLogProgress(Zcl, "Shutting down Sample Manufacturer Specific cluster, Ep %d", endpoint);
+ SampleExternalManufacturerSpecificServer::Instance().UnregisterEndpoint(endpoint);
+}
+
+// *****************************************************************************
+// SampleExternalManufacturerSpecificContent
+
+namespace chip {
+namespace app {
+namespace Clusters {
+namespace SampleExternalManufacturerSpecific {
+
+SampleExternalManufacturerSpecificContent::SampleExternalManufacturerSpecificContent() :
+ SampleExternalManufacturerSpecificContent(kInvalidEndpointId)
+{}
+
+SampleExternalManufacturerSpecificContent::SampleExternalManufacturerSpecificContent(EndpointId aEndpoint)
+{
+ endpoint = aEndpoint;
+ pingCount = 10000;
+
+ // Attribute default values
+ flipflop = false;
+}
+
+// *****************************************************************************
+// SampleExternalManufacturerSpecificServer
+
+void SampleExternalManufacturerSpecificServer::InvokeCommand(HandlerContext & ctxt)
+{
+ auto endpoint = ctxt.mRequestPath.mEndpointId;
+ auto fabricIndex = ctxt.mCommandHandler.GetAccessingFabricIndex();
+ auto endpointIndex = EndpointIndex(endpoint);
+ if (endpointIndex == std::numeric_limits<size_t>::max())
+ {
+ ctxt.mCommandHandler.AddStatus(ctxt.mRequestPath, Protocols::InteractionModel::Status::UnsupportedEndpoint);
+ return;
+ }
+
+ switch (ctxt.mRequestPath.mCommandId)
+ {
+ case Commands::Ping::Id:
+ HandleCommand<Commands::Ping::DecodableType>(
+ ctxt, [this, endpoint, fabricIndex, endpointIndex](HandlerContext & ctx, const auto & req) {
+ ChipLogProgress(Zcl, "Ping Command on Ep %d", endpoint);
+ // NOTE: fabricIndex did not get created by zap, thus I've removed isFabricSensitive="true" in the XML
+ // Events::PingCountEvent::Type event{ .count = content[endpointIndex].pingCount++, .fabricIndex = fabricIndex };
+ Events::PingCountEvent::Type event{ .count = content[endpointIndex].pingCount++ };
+ chip::EventNumber placeholderEventNumber;
+ CHIP_ERROR err = LogEvent(event, endpoint, placeholderEventNumber);
+ if (CHIP_NO_ERROR != err)
+ {
+ ChipLogError(Zcl, "Failed to record event on endpoint %d: %" CHIP_ERROR_FORMAT, static_cast<int>(endpoint),
+ err.Format());
+ }
+ ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Success);
+ });
+ return;
+ case Commands::AddArguments::Id:
+ HandleCommand<Commands::AddArguments::DecodableType>(ctxt, [endpoint](HandlerContext & ctx, const auto & req) {
+ ChipLogProgress(Zcl, "AddArgumentsCommand on Ep %d", endpoint);
+ if (req.arg1 > UINT8_MAX - req.arg2)
+ {
+ ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::InvalidCommand);
+ return;
+ }
+
+ AddArgumentsResponse::Type response;
+ response.returnValue = static_cast<uint8_t>(req.arg1 + req.arg2);
+ ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response);
+ });
+ return;
+ }
+}
+
+CHIP_ERROR SampleExternalManufacturerSpecificServer::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
+{
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ auto endpoint = aPath.mEndpointId;
+ auto endpointIndex = EndpointIndex(endpoint);
+ if (endpointIndex == std::numeric_limits<size_t>::max())
+ {
+ return CHIP_IM_GLOBAL_STATUS(UnsupportedEndpoint);
+ }
+
+ switch (aPath.mAttributeId)
+ {
+ case Attributes::FlipFlop::Id:
+ ChipLogProgress(Zcl, "Read Attribute flip-flop from Ep %d index %u value %d", endpoint,
+ static_cast<uint16_t>(endpointIndex), content[endpointIndex].flipflop);
+ err = aEncoder.Encode(content[endpointIndex].flipflop);
+ break;
+ default:
+ break;
+ }
+
+ return err;
+}
+
+CHIP_ERROR SampleExternalManufacturerSpecificServer::Write(const ConcreteDataAttributePath & aPath,
+ AttributeValueDecoder & aDecoder)
+{
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ auto endpoint = aPath.mEndpointId;
+ auto endpointIndex = EndpointIndex(endpoint);
+ if (endpointIndex == std::numeric_limits<size_t>::max())
+ {
+ return CHIP_IM_GLOBAL_STATUS(UnsupportedEndpoint);
+ }
+
+ switch (aPath.mAttributeId)
+ {
+ case Attributes::FlipFlop::Id: {
+ auto oldValue = content[endpointIndex].flipflop;
+ ReturnErrorOnFailure(aDecoder.Decode(content[endpointIndex].flipflop));
+ ChipLogProgress(Zcl, "Write Attribute flip-flop on Ep %d index %u newValue %d oldValue %d", endpoint,
+ static_cast<uint16_t>(endpointIndex), content[endpointIndex].flipflop, oldValue);
+ break;
+ }
+ default:
+ break;
+ }
+
+ return err;
+}
+
+SampleExternalManufacturerSpecificServer & SampleExternalManufacturerSpecificServer::Instance()
+{
+ static SampleExternalManufacturerSpecificServer sampleExternalManufacturerSpecificServer;
+ return sampleExternalManufacturerSpecificServer;
+}
+
+void SampleExternalManufacturerSpecificServer::Shutdown()
+{
+ for (size_t i = 0; i < kNumSupportedEndpoints; ++i)
+ {
+ content[i].endpoint = kInvalidEndpointId;
+ }
+}
+
+size_t SampleExternalManufacturerSpecificServer::GetNumSupportedEndpoints() const
+{
+ return kNumSupportedEndpoints;
+}
+
+CHIP_ERROR SampleExternalManufacturerSpecificServer::RegisterEndpoint(EndpointId endpointId)
+{
+ size_t endpointIndex = NextEmptyIndex();
+ if (endpointIndex == std::numeric_limits<size_t>::max())
+ {
+ return CHIP_ERROR_NO_MEMORY;
+ }
+
+ content[endpointIndex] = SampleExternalManufacturerSpecificContent(endpointId);
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR SampleExternalManufacturerSpecificServer::UnregisterEndpoint(EndpointId endpointId)
+{
+ size_t endpointIndex = EndpointIndex(endpointId);
+ if (endpointIndex == std::numeric_limits<size_t>::max())
+ {
+ return CHIP_ERROR_INVALID_ARGUMENT;
+ }
+
+ content[endpointIndex].endpoint = kInvalidEndpointId;
+ return CHIP_NO_ERROR;
+}
+
+size_t SampleExternalManufacturerSpecificServer::EndpointIndex(EndpointId endpointId) const
+{
+ for (size_t i = 0; i < kNumSupportedEndpoints; ++i)
+ {
+ if (content[i].endpoint == endpointId)
+ {
+ return i;
+ }
+ }
+ return std::numeric_limits<size_t>::max();
+}
+
+size_t SampleExternalManufacturerSpecificServer::NextEmptyIndex() const
+{
+ for (size_t i = 0; i < kNumSupportedEndpoints; ++i)
+ {
+ if (content[i].endpoint == kInvalidEndpointId)
+ {
+ return i;
+ }
+ }
+ return std::numeric_limits<size_t>::max();
+}
+
+} // namespace SampleExternalManufacturerSpecific
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/clusters/sample-external-manufacturer-specific-server.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/clusters/sample-external-manufacturer-specific-server.h
new file mode 100644
index 00000000000000..b3bbdf6cb6c709
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/clusters/sample-external-manufacturer-specific-server.h
@@ -0,0 +1,90 @@
+#ifndef SRC_APP_CLUSTERS_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_SERVER_H_
+#define SRC_APP_CLUSTERS_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_SERVER_H_
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/AttributeAccessInterface.h>
+#include <app/CommandHandlerInterface.h>
+#include <app/ConcreteCommandPath.h>
+#include <app/util/af-types.h>
+#include <app/util/basic-types.h>
+#include <app/util/config.h>
+#include <lib/support/Span.h>
+#include <platform/CHIPDeviceConfig.h>
+
+#ifdef ZCL_USING_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER
+#define SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS \
+ (MATTER_DM_SAMPLE_EXTERNAL_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT)
+#else
+#define SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT
+#endif /* ZCL_USING_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER */
+static constexpr size_t kNumSupportedEndpoints = SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS;
+
+namespace chip {
+namespace app {
+namespace Clusters {
+namespace SampleExternalManufacturerSpecific {
+
+// *****************************************************************************
+// SampleExternalManufacturerSpecificContent has the stateful attributes of the cluster: its endpoint
+// and attributes
+
+class SampleExternalManufacturerSpecificContent
+{
+public:
+ EndpointId endpoint;
+ uint32_t pingCount;
+
+ // Attribute List
+ bool flipflop; /* Attributes::FlipFlop::Id */
+
+ SampleExternalManufacturerSpecificContent(EndpointId endpoint);
+ SampleExternalManufacturerSpecificContent();
+};
+
+// *****************************************************************************
+// SampleExternalManufacturerSpecificServer implements both Attributes and Commands
+
+class SampleExternalManufacturerSpecificServer : public AttributeAccessInterface, public CommandHandlerInterface
+{
+public:
+ // Register on all endpoints.
+ SampleExternalManufacturerSpecificServer() :
+ AttributeAccessInterface(Optional<EndpointId>::Missing(), SampleExternalManufacturerSpecific::Id),
+ CommandHandlerInterface(Optional<EndpointId>(), Id)
+ {}
+ static SampleExternalManufacturerSpecificServer & Instance();
+
+ // Currently not used, but should be called from a whole-cluster shutdown
+ // callback once cluster lifecycle is clearer
+ void Shutdown();
+
+ // Attributes
+ CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override;
+ CHIP_ERROR Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) override;
+
+ // Commands
+ void InvokeCommand(HandlerContext & ctx) override;
+
+ // Attribute storage
+#if SAMPLE_EXTERNAL_MEI_NUM_SUPPORTED_ENDPOINTS > 0
+ SampleExternalManufacturerSpecificContent content[kNumSupportedEndpoints];
+#else
+ SampleExternalManufacturerSpecificContent * content = nullptr;
+#endif
+
+ size_t GetNumSupportedEndpoints() const;
+ CHIP_ERROR RegisterEndpoint(EndpointId endpointId);
+ CHIP_ERROR UnregisterEndpoint(EndpointId endpointId);
+
+private:
+ // both return std::numeric_limits<size_t>::max() for not found
+ size_t EndpointIndex(EndpointId endpointId) const;
+ size_t NextEmptyIndex() const;
+};
+
+} // namespace SampleExternalManufacturerSpecific
+} // namespace Clusters
+} // namespace app
+} // namespace chip
+
+#endif // SRC_APP_CLUSTERS_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_SERVER_H_
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/config-data.yaml b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/config-data.yaml
new file mode 100755
index 00000000000000..38ff2528752bba
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/config-data.yaml
@@ -0,0 +1,105 @@
+EnumsNotUsedAsTypeInXML:
+ # List of enums that are not used as a type in XML. By adding an enum
+ # to this list you prevent incorrectly assuming from code that you are
+ # able to use kUnknownEnumValue safely. This happens for derived clusters
+ # such as ModeBase where there are CommonTag, DerivedClusterTags, MfgTags.
+ - "DishwasherMode::ModeTag"
+ - "LaundryWasherMode::ModeTag"
+ - "RefrigeratorAndTemperatureControlledCabinetMode::ModeTag"
+ - "RvcRunMode::ModeTag"
+ - "RvcRunMode::StatusCode"
+ - "RvcCleanMode::ModeTag"
+ - "RvcCleanMode::StatusCode"
+ - "RvcOperationalState::OperationalStateEnum"
+ - "RvcOperationalState::ErrorStateEnum"
+ - "EnergyEvseMode::ModeTag"
+ - "WaterHeaterMode::ModeTag"
+ - "DeviceEnergyManagementMode::ModeTag"
+
+CommandHandlerInterfaceOnlyClusters:
+ # List of clusters that are implemented entirely with
+ # CommandHandlerInterface and hence do not need generated command dispatch.
+ # This uses asUpperCamelCase versions of the cluster name.
+ - Network Commissioning
+ - Scenes Management
+ - RVC Run Mode
+ - RVC Clean Mode
+ - Service Area
+ - Dishwasher Mode
+ - Laundry Washer Mode
+ - Oven Mode
+ - Oven Cavity Operational State
+ - Refrigerator And Temperature Controlled Cabinet Mode
+ - Operational State
+ - Activated Carbon Filter Monitoring
+ - HEPA Filter Monitoring
+ - RVC Operational State
+ - Sample External Manufacturer-Specific
+ - Sample Manufacturer-Specific
+ - Microwave Oven Control
+ - Chime
+ - Commissioner Control
+ - Energy EVSE
+ - Energy EVSE Mode
+ - Device Energy Management
+ - Device Energy Management Mode
+ - Electrical Power Measurement
+ - Electrical Energy Measurement
+ - Wi-Fi Network Management
+ - Thread Border Router Management
+ - Thread Network Directory
+ - Water Heater Management
+ - Water Heater Mode
+ - General Commissioning
+ - Software Diagnostics
+
+# We need a more configurable way of deciding which clusters have which init functions....
+# See https://github.com/project-chip/connectedhomeip/issues/4369
+ClustersWithInitFunctions:
+ - Color Control
+ - Groups
+ - Identify
+ - Level Control
+ - Localization Configuration
+ - Occupancy Sensing
+ - On/Off
+ - Pump Configuration and Control
+ - Time Format Localization
+ - Thermostat
+ - Mode Select
+ - Sample External Manufacturer-Specific
+ - Sample Manufacturer-Specific
+ - Scenes Management
+
+ClustersWithAttributeChangedFunctions:
+ - Bridged Device Basic
+ - Door Lock
+ - Identify
+ - Pump Configuration and Control
+ - Window Covering
+ - Fan Control
+ - Thermostat
+
+ClustersWithShutdownFunctions:
+ - Barrier Control
+ - On/Off
+ - Door Lock
+ - Level Control
+ - Color Control
+ - Sample External Manufacturer-Specific
+ - Sample Manufacturer-Specific
+ - Scenes Management
+ - Thermostat
+
+ClustersWithPreAttributeChangeFunctions:
+ - Door Lock
+ - Pump Configuration and Control
+ - Thermostat User Interface Configuration
+ - Time Format Localization
+ - Localization Configuration
+ - Mode Select
+ - Fan Control
+ - Thermostat
+ - Energy Preference
+ - Laundry Washer Controls
+ - Laundry Dryer Controls
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/xml/sample-external-manufacturer-specific-cluster.xml b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/xml/sample-external-manufacturer-specific-cluster.xml
new file mode 100644
index 00000000000000..92e1ea70f4ff1f
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/xml/sample-external-manufacturer-specific-cluster.xml
@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<!--
+Copyright (c) 2023 Project CHIP Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+<configurator>
+ <domain name="CHIP"/>
+
+ <cluster>
+ <domain>General</domain>
+ <name>Sample External Manufacturer-Specific</name>
+ <!-- The MSB 16 bits of <code> are the VendorID. Replace this with your
+ VendorID. 0xFFF1 is a Test VendorID.
+
+ The LSB 16 bits of <code> are a self-assigned ClusterID -->
+ <code>0xFFF1FC21</code>
+ <define>SAMPLE_EXTERNAL_MANUFACTURER_SPECIFIC_CLUSTER</define>
+ <description>A sample showcasing an out-of-tree definition of a manufacturer specific cluster</description>
+
+ <!-- Attributes -->
+ <!-- A simple boolean attribute that flips or flops -->
+ <attribute side="server" code="0x0000" define="FLIP_FLOP" type="boolean" writable="true" default="false" optional="false">FlipFlop</attribute>
+
+ <!-- Command Responses -->
+ <command source="server" code="0x01" name="AddArgumentsResponse" optional="false" disableDefaultResponse="true">
+ <description>
+ Response for AddArguments that returns the sum.
+ </description>
+ <arg name="returnValue" type="int8u"/>
+ </command>
+
+ <!-- Commands -->
+ <command source="client" code="0x02" name="AddArguments" response="AddArgumentsResponse" optional="false">
+ <description>
+ Command that takes two uint8 arguments and returns their sum.
+ </description>
+ <arg name="arg1" type="int8u"/>
+ <arg name="arg2" type="int8u"/>
+ </command>
+
+ <command source="client" code="0x00" name="Ping" optional="false">
+ <description>
+ Simple command without any parameters and without a response.
+ </description>
+ </command>
+
+ <!-- Events -->
+ <event side="server" code="0x0000" name="PingCountEvent" priority="info" optional="false">
+ <description>Example events generated by Ping command</description>
+ <field id="1" name="count" type="int32u"/>
+ </event>
+ </cluster>
+</configurator>
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attribute-type.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attribute-type.h
new file mode 100644
index 00000000000000..ae493673fc03f2
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attribute-type.h
@@ -0,0 +1,142 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+// Prevent multiple inclusion
+#pragma once
+
+#include <cstdint>
+
+// ZCL attribute types
+enum
+{
+ ZCL_NO_DATA_ATTRIBUTE_TYPE = 0x00, // No data
+ ZCL_BOOLEAN_ATTRIBUTE_TYPE = 0x10, // Boolean
+ ZCL_BITMAP8_ATTRIBUTE_TYPE = 0x18, // 8-bit bitmap
+ ZCL_BITMAP16_ATTRIBUTE_TYPE = 0x19, // 16-bit bitmap
+ ZCL_BITMAP32_ATTRIBUTE_TYPE = 0x1B, // 32-bit bitmap
+ ZCL_BITMAP64_ATTRIBUTE_TYPE = 0x1F, // 64-bit bitmap
+ ZCL_INT8U_ATTRIBUTE_TYPE = 0x20, // Unsigned 8-bit integer
+ ZCL_INT16U_ATTRIBUTE_TYPE = 0x21, // Unsigned 16-bit integer
+ ZCL_INT24U_ATTRIBUTE_TYPE = 0x22, // Unsigned 24-bit integer
+ ZCL_INT32U_ATTRIBUTE_TYPE = 0x23, // Unsigned 32-bit integer
+ ZCL_INT40U_ATTRIBUTE_TYPE = 0x24, // Unsigned 40-bit integer
+ ZCL_INT48U_ATTRIBUTE_TYPE = 0x25, // Unsigned 48-bit integer
+ ZCL_INT56U_ATTRIBUTE_TYPE = 0x26, // Unsigned 56-bit integer
+ ZCL_INT64U_ATTRIBUTE_TYPE = 0x27, // Unsigned 64-bit integer
+ ZCL_INT8S_ATTRIBUTE_TYPE = 0x28, // Signed 8-bit integer
+ ZCL_INT16S_ATTRIBUTE_TYPE = 0x29, // Signed 16-bit integer
+ ZCL_INT24S_ATTRIBUTE_TYPE = 0x2A, // Signed 24-bit integer
+ ZCL_INT32S_ATTRIBUTE_TYPE = 0x2B, // Signed 32-bit integer
+ ZCL_INT40S_ATTRIBUTE_TYPE = 0x2C, // Signed 40-bit integer
+ ZCL_INT48S_ATTRIBUTE_TYPE = 0x2D, // Signed 48-bit integer
+ ZCL_INT56S_ATTRIBUTE_TYPE = 0x2E, // Signed 56-bit integer
+ ZCL_INT64S_ATTRIBUTE_TYPE = 0x2F, // Signed 64-bit integer
+ ZCL_ENUM8_ATTRIBUTE_TYPE = 0x30, // 8-bit enumeration
+ ZCL_ENUM16_ATTRIBUTE_TYPE = 0x31, // 16-bit enumeration
+ ZCL_PRIORITY_ATTRIBUTE_TYPE = 0x32, // Priority
+ ZCL_STATUS_ATTRIBUTE_TYPE = 0x33, // Status Code
+ ZCL_SINGLE_ATTRIBUTE_TYPE = 0x39, // Single precision
+ ZCL_DOUBLE_ATTRIBUTE_TYPE = 0x3A, // Double precision
+ ZCL_OCTET_STRING_ATTRIBUTE_TYPE = 0x41, // Octet String
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE = 0x42, // Character String
+ ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE = 0x43, // Long Octet String
+ ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE = 0x44, // Long Character String
+ ZCL_ARRAY_ATTRIBUTE_TYPE = 0x48, // List
+ ZCL_STRUCT_ATTRIBUTE_TYPE = 0x4C, // Structure
+ ZCL_GROUP_ID_ATTRIBUTE_TYPE = 0xC0, // Group ID
+ ZCL_ENDPOINT_NO_ATTRIBUTE_TYPE = 0xC1, // Endpoint Number
+ ZCL_VENDOR_ID_ATTRIBUTE_TYPE = 0xC2, // Vendor ID
+ ZCL_DEVTYPE_ID_ATTRIBUTE_TYPE = 0xC3, // Device Type ID
+ ZCL_FABRIC_ID_ATTRIBUTE_TYPE = 0xC4, // Fabric ID
+ ZCL_FABRIC_IDX_ATTRIBUTE_TYPE = 0xC5, // Fabric Index
+ ZCL_ENTRY_IDX_ATTRIBUTE_TYPE = 0xC6, // Entry Index
+ ZCL_DATA_VER_ATTRIBUTE_TYPE = 0xC7, // Data Version
+ ZCL_EVENT_NO_ATTRIBUTE_TYPE = 0xC8, // Event Number
+ ZCL_SEMTAG_ATTRIBUTE_TYPE = 0xC9, // Semantic Tag
+ ZCL_NAMESPACE_ATTRIBUTE_TYPE = 0xCA, // Namespace
+ ZCL_TAG_ATTRIBUTE_TYPE = 0xCB, // Tag
+ ZCL_SYSTIME_US_ATTRIBUTE_TYPE = 0xD0, // System Time Microseconds
+ ZCL_SYSTIME_MS_ATTRIBUTE_TYPE = 0xD1, // System Time Milliseconds
+ ZCL_ELAPSED_S_ATTRIBUTE_TYPE = 0xD2, // Elapsed Time Seconds
+ ZCL_TEMPERATURE_ATTRIBUTE_TYPE = 0xD8, // Temperature
+ ZCL_POWER_MW_ATTRIBUTE_TYPE = 0xD9, // Power milliwatts
+ ZCL_AMPERAGE_MA_ATTRIBUTE_TYPE = 0xDA, // Amperage milliamps
+ ZCL_VOLTAGE_MV_ATTRIBUTE_TYPE = 0xDB, // Voltage millivolts
+ ZCL_ENERGY_MWH_ATTRIBUTE_TYPE = 0xDC, // Energy milliwatt-hours
+ ZCL_TOD_ATTRIBUTE_TYPE = 0xE0, // Time of day
+ ZCL_DATE_ATTRIBUTE_TYPE = 0xE1, // Date
+ ZCL_EPOCH_US_ATTRIBUTE_TYPE = 0xE3, // Epoch Microseconds
+ ZCL_EPOCH_S_ATTRIBUTE_TYPE = 0xE4, // Epoch Seconds
+ ZCL_POSIX_MS_ATTRIBUTE_TYPE = 0xE5, // Posix Time Milliseconds
+ ZCL_PERCENT_ATTRIBUTE_TYPE = 0xE6, // Percentage units 1%
+ ZCL_PERCENT100THS_ATTRIBUTE_TYPE = 0xE7, // Percentage units 0.01%
+ ZCL_CLUSTER_ID_ATTRIBUTE_TYPE = 0xE8, // Cluster ID
+ ZCL_ATTRIB_ID_ATTRIBUTE_TYPE = 0xE9, // Attribute ID
+ ZCL_FIELD_ID_ATTRIBUTE_TYPE = 0xEB, // Field ID
+ ZCL_EVENT_ID_ATTRIBUTE_TYPE = 0xEC, // Event ID
+ ZCL_COMMAND_ID_ATTRIBUTE_TYPE = 0xED, // Command ID
+ ZCL_ACTION_ID_ATTRIBUTE_TYPE = 0xEE, // Action ID
+ ZCL_TRANS_ID_ATTRIBUTE_TYPE = 0xEF, // Transaction ID
+ ZCL_NODE_ID_ATTRIBUTE_TYPE = 0xF0, // Node ID
+ ZCL_IPADR_ATTRIBUTE_TYPE = 0xF2, // IP Address
+ ZCL_IPV4ADR_ATTRIBUTE_TYPE = 0xF3, // IPv4 Address
+ ZCL_IPV6ADR_ATTRIBUTE_TYPE = 0xF4, // IPv6 Address
+ ZCL_IPV6PRE_ATTRIBUTE_TYPE = 0xF5, // IPv6 Prefix
+ ZCL_HWADR_ATTRIBUTE_TYPE = 0xF6, // Hardware Address
+ ZCL_UNKNOWN_ATTRIBUTE_TYPE = 0xFF, // Unknown
+};
+
+namespace chip {
+namespace app {
+inline bool IsSignedAttributeType(uint8_t attributeType)
+{
+ switch (attributeType)
+ {
+ case ZCL_INT8S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT16S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT24S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT32S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT40S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT48S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT56S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_INT64S_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_TEMPERATURE_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_POWER_MW_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_AMPERAGE_MA_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_VOLTAGE_MV_ATTRIBUTE_TYPE:
+ return true;
+ case ZCL_ENERGY_MWH_ATTRIBUTE_TYPE:
+ return true;
+ default:
+ return false;
+ }
+}
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
new file mode 100644
index 00000000000000..947440eaacc99c
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
@@ -0,0 +1,44715 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+/**
+ * @file
+ * This file contains definitions for accessors around clusters attributes.
+ */
+
+#include <app-common/zap-generated/attributes/Accessors.h>
+
+#include <app-common/zap-generated/attribute-type.h>
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/util/attribute-storage-null-handling.h>
+#include <app/util/attribute-table.h>
+#include <app/util/odd-sized-integers.h>
+#include <lib/core/CHIPEncoding.h>
+#include <lib/support/logging/CHIPLogging.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace Identify {
+namespace Attributes {
+
+namespace IdentifyTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Identify::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Identify::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Identify::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace IdentifyTime
+
+namespace IdentifyType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Identify::IdentifyTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Identify::IdentifyTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Identify::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Identify::IdentifyTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Identify::IdentifyTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Identify::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Identify::IdentifyTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Identify::IdentifyTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Identify::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace IdentifyType
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Identify::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Identify::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Identify::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Identify::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Identify::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Identify::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Identify
+
+namespace Groups {
+namespace Attributes {
+
+namespace NameSupport {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Groups::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Groups::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Groups::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace NameSupport
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Groups::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Groups::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Groups::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Groups::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Groups::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Groups::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Groups
+
+namespace OnOff {
+namespace Attributes {
+
+namespace OnOff {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace OnOff
+
+namespace GlobalSceneControl {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace GlobalSceneControl
+
+namespace OnTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace OnTime
+
+namespace OffWaitTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace OffWaitTime
+
+namespace StartUpOnOff {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OnOff::StartUpOnOffEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OnOff::StartUpOnOffEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpOnOff
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OnOff::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OnOff::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OnOff::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OnOff
+
+namespace LevelControl {
+namespace Attributes {
+
+namespace CurrentLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentLevel
+
+namespace RemainingTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace RemainingTime
+
+namespace MinLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinLevel
+
+namespace MaxLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxLevel
+
+namespace CurrentFrequency {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentFrequency
+
+namespace MinFrequency {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinFrequency
+
+namespace MaxFrequency {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxFrequency
+
+namespace Options {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Options
+
+namespace OnOffTransitionTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace OnOffTransitionTime
+
+namespace OnLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnLevel
+
+namespace OnTransitionTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnTransitionTime
+
+namespace OffTransitionTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OffTransitionTime
+
+namespace DefaultMoveRate {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace DefaultMoveRate
+
+namespace StartUpCurrentLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpCurrentLevel
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LevelControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LevelControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LevelControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LevelControl
+
+namespace PulseWidthModulation {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PulseWidthModulation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PulseWidthModulation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PulseWidthModulation::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PulseWidthModulation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PulseWidthModulation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PulseWidthModulation::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PulseWidthModulation
+
+namespace Descriptor {
+namespace Attributes {} // namespace Attributes
+} // namespace Descriptor
+
+namespace Binding {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Binding::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Binding::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Binding::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Binding::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Binding::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Binding::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Binding
+
+namespace AccessControl {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AccessControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AccessControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AccessControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+} // namespace Attributes
+} // namespace AccessControl
+
+namespace Actions {
+namespace Attributes {
+
+namespace SetupURL {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[512 + 2];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Actions::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfLongStringLength(zclString);
+ if (length == NumericAttributeTraits<uint16_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 512, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[2], 512);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(512 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 512, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[512 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Actions::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(512 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 512, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[512 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::Actions::Id, Id, zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace SetupURL
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Actions::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Actions::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Actions::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Actions::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Actions::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Actions::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Actions
+
+namespace BasicInformation {
+namespace Attributes {
+
+namespace NodeLabel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BasicInformation::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace NodeLabel
+
+namespace LocalConfigDisabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BasicInformation::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace LocalConfigDisabled
+
+namespace Reachable {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BasicInformation::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace Reachable
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BasicInformation::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BasicInformation::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BasicInformation
+
+namespace OtaSoftwareUpdateProvider {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateProvider::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateProvider::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateProvider::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateProvider::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateProvider::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateProvider::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateProvider
+
+namespace OtaSoftwareUpdateRequestor {
+namespace Attributes {
+
+namespace UpdatePossible {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace UpdatePossible
+
+namespace UpdateState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace UpdateState
+
+namespace UpdateStateProgress {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace UpdateStateProgress
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OtaSoftwareUpdateRequestor::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateRequestor
+
+namespace LocalizationConfiguration {
+namespace Attributes {
+
+namespace ActiveLocale {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[35 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LocalizationConfiguration::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 35, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 35);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(35 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 35, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[35 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LocalizationConfiguration::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(35 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 35, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[35 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::LocalizationConfiguration::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ActiveLocale
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LocalizationConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LocalizationConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LocalizationConfiguration::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LocalizationConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LocalizationConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LocalizationConfiguration::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LocalizationConfiguration
+
+namespace TimeFormatLocalization {
+namespace Attributes {
+
+namespace HourFormat {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeFormatLocalization::HourFormatEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeFormatLocalization::HourFormatEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeFormatLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeFormatLocalization::HourFormatEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace HourFormat
+
+namespace ActiveCalendarType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeFormatLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ActiveCalendarType
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeFormatLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeFormatLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeFormatLocalization::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TimeFormatLocalization
+
+namespace UnitLocalization {
+namespace Attributes {
+
+namespace TemperatureUnit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitLocalization::TempUnitEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitLocalization::TempUnitEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitLocalization::TempUnitEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitLocalization::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TemperatureUnit
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitLocalization::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitLocalization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitLocalization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitLocalization::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace UnitLocalization
+
+namespace PowerSourceConfiguration {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSourceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSourceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSourceConfiguration::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSourceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSourceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSourceConfiguration::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerSourceConfiguration
+
+namespace PowerSource {
+namespace Attributes {
+
+namespace Status {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::PowerSourceStatusEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::PowerSourceStatusEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::PowerSourceStatusEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::PowerSourceStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::PowerSourceStatusEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::PowerSourceStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Status
+
+namespace Order {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Order
+
+namespace Description {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[60 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 60, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 60);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(60 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 60, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[60 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(60 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 60, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[60 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace Description
+
+namespace WiredAssessedInputVoltage {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace WiredAssessedInputVoltage
+
+namespace WiredAssessedInputFrequency {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace WiredAssessedInputFrequency
+
+namespace WiredCurrentType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::WiredCurrentTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::WiredCurrentTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::WiredCurrentTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace WiredCurrentType
+
+namespace WiredAssessedCurrent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace WiredAssessedCurrent
+
+namespace WiredNominalVoltage {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace WiredNominalVoltage
+
+namespace WiredMaximumCurrent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace WiredMaximumCurrent
+
+namespace WiredPresent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace WiredPresent
+
+namespace BatVoltage {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace BatVoltage
+
+namespace BatPercentRemaining {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace BatPercentRemaining
+
+namespace BatTimeRemaining {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace BatTimeRemaining
+
+namespace BatChargeLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatChargeLevelEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatChargeLevelEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatChargeLevelEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatChargeLevel
+
+namespace BatReplacementNeeded {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatReplacementNeeded
+
+namespace BatReplaceability {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatReplaceabilityEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatReplaceabilityEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatReplaceabilityEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatReplaceabilityEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatReplaceabilityEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatReplaceabilityEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatReplaceability
+
+namespace BatPresent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatPresent
+
+namespace BatReplacementDescription {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[60 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 60, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 60);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(60 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 60, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[60 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(60 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 60, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[60 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatReplacementDescription
+
+namespace BatCommonDesignation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatCommonDesignationEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatCommonDesignationEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatCommonDesignationEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatCommonDesignation
+
+namespace BatANSIDesignation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[20 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 20, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 20);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(20 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 20, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[20 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(20 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 20, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[20 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatANSIDesignation
+
+namespace BatIECDesignation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[20 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 20, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 20);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(20 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 20, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[20 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(20 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 20, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[20 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatIECDesignation
+
+namespace BatApprovedChemistry {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatApprovedChemistryEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatApprovedChemistryEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatApprovedChemistryEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatApprovedChemistry
+
+namespace BatCapacity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatCapacity
+
+namespace BatQuantity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatQuantity
+
+namespace BatChargeState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatChargeStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatChargeStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PowerSource::BatChargeStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatChargeState
+
+namespace BatTimeToFullCharge {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace BatTimeToFullCharge
+
+namespace BatFunctionalWhileCharging {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatFunctionalWhileCharging
+
+namespace BatChargingCurrent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace BatChargingCurrent
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerSource::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerSource::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerSource::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerSource
+
+namespace GeneralCommissioning {
+namespace Attributes {
+
+namespace Breadcrumb {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Breadcrumb
+
+namespace TCAcceptedVersion {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace TCAcceptedVersion
+
+namespace TCMinRequiredVersion {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace TCMinRequiredVersion
+
+namespace TCAcknowledgements {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace TCAcknowledgements
+
+namespace TCAcknowledgementsRequired {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace TCAcknowledgementsRequired
+
+namespace TCUpdateDeadline {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace TCUpdateDeadline
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralCommissioning::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace GeneralCommissioning
+
+namespace NetworkCommissioning {
+namespace Attributes {
+
+namespace MaxNetworks {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxNetworks
+
+namespace ScanMaxTimeSeconds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ScanMaxTimeSeconds
+
+namespace ConnectMaxTimeSeconds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ConnectMaxTimeSeconds
+
+namespace InterfaceEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace InterfaceEnabled
+
+namespace LastNetworkingStatus {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LastNetworkingStatus
+
+namespace LastNetworkID {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ ChipLogError(Zcl, "Null Nullable<Span> passed to NetworkCommissioning::LastNetworkID::Get");
+ return Protocols::InteractionModel::Status::Failure;
+ }
+
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ value.SetNull();
+ return Protocols::InteractionModel::Status::Success;
+ }
+ auto & span = value.Value();
+
+ VerifyOrReturnError(span.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(span.data(), &zclString[1], 32);
+ span.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LastNetworkID
+
+namespace LastConnectErrorValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int32_t> & value)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LastConnectErrorValue
+
+namespace SupportedThreadFeatures {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace SupportedThreadFeatures
+
+namespace ThreadVersion {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ThreadVersion
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NetworkCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NetworkCommissioning::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace NetworkCommissioning
+
+namespace DiagnosticLogs {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DiagnosticLogs::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DiagnosticLogs::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DiagnosticLogs::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DiagnosticLogs::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DiagnosticLogs::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DiagnosticLogs::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DiagnosticLogs
+
+namespace GeneralDiagnostics {
+namespace Attributes {
+
+namespace TestEventTriggersEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::GeneralDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::GeneralDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::GeneralDiagnostics::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace TestEventTriggersEnabled
+
+} // namespace Attributes
+} // namespace GeneralDiagnostics
+
+namespace SoftwareDiagnostics {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SoftwareDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SoftwareDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SoftwareDiagnostics::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SoftwareDiagnostics
+
+namespace ThreadNetworkDiagnostics {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThreadNetworkDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThreadNetworkDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThreadNetworkDiagnostics::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThreadNetworkDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThreadNetworkDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThreadNetworkDiagnostics::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadNetworkDiagnostics
+
+namespace WiFiNetworkDiagnostics {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WiFiNetworkDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WiFiNetworkDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WiFiNetworkDiagnostics::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WiFiNetworkDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WiFiNetworkDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WiFiNetworkDiagnostics::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WiFiNetworkDiagnostics
+
+namespace EthernetNetworkDiagnostics {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EthernetNetworkDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EthernetNetworkDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EthernetNetworkDiagnostics::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EthernetNetworkDiagnostics::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EthernetNetworkDiagnostics::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EthernetNetworkDiagnostics::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EthernetNetworkDiagnostics
+
+namespace TimeSynchronization {
+namespace Attributes {
+
+namespace TimeSource {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeSynchronization::TimeSourceEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeSynchronization::TimeSourceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeSynchronization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeSynchronization::TimeSourceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TimeSource
+
+namespace TimeZoneDatabase {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeSynchronization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TimeZoneDatabase
+
+namespace NTPServerAvailable {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeSynchronization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace NTPServerAvailable
+
+namespace SupportsDNSResolve {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeSynchronization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace SupportsDNSResolve
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeSynchronization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TimeSynchronization::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TimeSynchronization
+
+namespace BridgedDeviceBasicInformation {
+namespace Attributes {
+
+namespace VendorName {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace VendorName
+
+namespace VendorID {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::VendorId * value)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_VENDOR_ID_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_VENDOR_ID_ATTRIBUTE_TYPE);
+}
+
+} // namespace VendorID
+
+namespace ProductName {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ProductName
+
+namespace ProductID {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ProductID
+
+namespace NodeLabel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace NodeLabel
+
+namespace HardwareVersion {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace HardwareVersion
+
+namespace HardwareVersionString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[64 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 64, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 64);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace HardwareVersionString
+
+namespace SoftwareVersion {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SoftwareVersion
+
+namespace SoftwareVersionString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[64 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 64, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 64);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace SoftwareVersionString
+
+namespace ManufacturingDate {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[16 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 16, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 16);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ManufacturingDate
+
+namespace PartNumber {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace PartNumber
+
+namespace ProductURL {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[256 + 2];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfLongStringLength(zclString);
+ if (length == NumericAttributeTraits<uint16_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 256, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[2], 256);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(256 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 256, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[256 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(256 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 256, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[256 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ProductURL
+
+namespace ProductLabel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[64 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 64, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 64);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ProductLabel
+
+namespace SerialNumber {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace SerialNumber
+
+namespace Reachable {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace Reachable
+
+namespace UniqueID {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, zclString,
+ ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace UniqueID
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BridgedDeviceBasicInformation::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BridgedDeviceBasicInformation
+
+namespace Switch {
+namespace Attributes {
+
+namespace NumberOfPositions {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Switch::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Switch::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Switch::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfPositions
+
+namespace CurrentPosition {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Switch::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Switch::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Switch::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentPosition
+
+namespace MultiPressMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Switch::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Switch::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Switch::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MultiPressMax
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Switch::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Switch::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Switch::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Switch::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Switch::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Switch::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Switch
+
+namespace AdministratorCommissioning {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AdministratorCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AdministratorCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AdministratorCommissioning::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AdministratorCommissioning::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AdministratorCommissioning::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AdministratorCommissioning::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AdministratorCommissioning
+
+namespace OperationalCredentials {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OperationalCredentials::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OperationalCredentials::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OperationalCredentials::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OperationalCredentials::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OperationalCredentials::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OperationalCredentials::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OperationalCredentials
+
+namespace GroupKeyManagement {
+namespace Attributes {} // namespace Attributes
+} // namespace GroupKeyManagement
+
+namespace FixedLabel {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FixedLabel::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FixedLabel::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FixedLabel::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FixedLabel::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FixedLabel::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FixedLabel::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FixedLabel
+
+namespace UserLabel {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UserLabel::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UserLabel::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UserLabel::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UserLabel::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UserLabel::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UserLabel::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace UserLabel
+
+namespace ProxyConfiguration {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ProxyConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ProxyConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ProxyConfiguration::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ProxyConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ProxyConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ProxyConfiguration::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyConfiguration
+
+namespace ProxyDiscovery {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ProxyDiscovery::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ProxyDiscovery::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ProxyDiscovery::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ProxyDiscovery::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ProxyDiscovery::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ProxyDiscovery::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyDiscovery
+
+namespace ProxyValid {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ProxyValid::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ProxyValid::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ProxyValid::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ProxyValid::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ProxyValid::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ProxyValid::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyValid
+
+namespace BooleanState {
+namespace Attributes {
+
+namespace StateValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanState::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace StateValue
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanState::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanState::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BooleanState
+
+namespace IcdManagement {
+namespace Attributes {
+
+namespace UserActiveModeTriggerHint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IcdManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IcdManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IcdManagement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace UserActiveModeTriggerHint
+
+namespace UserActiveModeTriggerInstruction {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[128 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IcdManagement::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 128, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 128);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(128 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 128, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[128 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IcdManagement::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(128 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 128, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[128 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::IcdManagement::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace UserActiveModeTriggerInstruction
+
+namespace OperatingMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::IcdManagement::OperatingModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IcdManagement::OperatingModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IcdManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IcdManagement::OperatingModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IcdManagement::OperatingModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IcdManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IcdManagement::OperatingModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IcdManagement::OperatingModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IcdManagement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace OperatingMode
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IcdManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IcdManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IcdManagement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IcdManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IcdManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IcdManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace IcdManagement
+
+namespace Timer {
+namespace Attributes {
+
+namespace SetTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Timer::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Timer::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Timer::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace SetTime
+
+namespace TimeRemaining {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Timer::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Timer::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Timer::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace TimeRemaining
+
+namespace TimerState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Timer::TimerStatusEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Timer::TimerStatusEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Timer::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Timer::TimerStatusEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Timer::TimerStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Timer::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Timer::TimerStatusEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Timer::TimerStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Timer::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TimerState
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Timer::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Timer::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Timer::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Timer::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Timer::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Timer::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Timer
+
+namespace OvenCavityOperationalState {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OvenCavityOperationalState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenCavityOperationalState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenCavityOperationalState::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OvenCavityOperationalState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenCavityOperationalState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenCavityOperationalState::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OvenCavityOperationalState
+
+namespace OvenMode {
+namespace Attributes {
+
+namespace CurrentMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OvenMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentMode
+
+namespace StartUpMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OvenMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpMode
+
+namespace OnMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OvenMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnMode
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OvenMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::OvenMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OvenMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OvenMode
+
+namespace LaundryDryerControls {
+namespace Attributes {
+
+namespace SelectedDrynessLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryDryerControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryDryerControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SelectedDrynessLevel
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryDryerControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryDryerControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryDryerControls::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryDryerControls
+
+namespace ModeSelect {
+namespace Attributes {
+
+namespace Description {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[64 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 64, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 64);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(64 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 64, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[64 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace Description
+
+namespace StandardNamespace {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StandardNamespace
+
+namespace CurrentMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentMode
+
+namespace StartUpMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpMode
+
+namespace OnMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnMode
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ModeSelect::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ModeSelect::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ModeSelect::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ModeSelect
+
+namespace LaundryWasherMode {
+namespace Attributes {
+
+namespace StartUpMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpMode
+
+namespace OnMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnMode
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryWasherMode
+
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+namespace Attributes {
+
+namespace StartUpMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, writable,
+ ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, writable,
+ ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpMode
+
+namespace OnMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, writable,
+ ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, writable,
+ ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnMode
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+
+namespace LaundryWasherControls {
+namespace Attributes {
+
+namespace SpinSpeedCurrent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SpinSpeedCurrent
+
+namespace NumberOfRinses {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfRinses
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LaundryWasherControls::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LaundryWasherControls::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryWasherControls
+
+namespace RvcRunMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RvcRunMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RvcRunMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RvcRunMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcRunMode
+
+namespace RvcCleanMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RvcCleanMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RvcCleanMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RvcCleanMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcCleanMode
+
+namespace TemperatureControl {
+namespace Attributes {
+
+namespace TemperatureSetpoint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace TemperatureSetpoint
+
+namespace MinTemperature {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinTemperature
+
+namespace MaxTemperature {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxTemperature
+
+namespace Step {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace Step
+
+namespace SelectedTemperatureLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SelectedTemperatureLevel
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TemperatureControl
+
+namespace RefrigeratorAlarm {
+namespace Attributes {
+
+namespace Mask {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Mask
+
+namespace State {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace State
+
+namespace Supported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Supported
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RefrigeratorAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAlarm
+
+namespace DishwasherMode {
+namespace Attributes {
+
+namespace StartUpMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpMode
+
+namespace OnMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherMode::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OnMode
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DishwasherMode
+
+namespace AirQuality {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AirQuality::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AirQuality::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AirQuality::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AirQuality
+
+namespace SmokeCoAlarm {
+namespace Attributes {
+
+namespace ExpressedState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ExpressedState
+
+namespace SmokeState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace SmokeState
+
+namespace COState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace COState
+
+namespace BatteryAlert {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace BatteryAlert
+
+namespace DeviceMuted {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::MuteStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::MuteStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::MuteStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace DeviceMuted
+
+namespace TestInProgress {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace TestInProgress
+
+namespace HardwareFaultAlert {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace HardwareFaultAlert
+
+namespace EndOfServiceAlert {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace EndOfServiceAlert
+
+namespace InterconnectSmokeAlarm {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace InterconnectSmokeAlarm
+
+namespace InterconnectCOAlarm {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace InterconnectCOAlarm
+
+namespace ContaminationState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ContaminationState
+
+namespace SmokeSensitivityLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::SensitivityEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::SensitivityEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::SensitivityEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace SmokeSensitivityLevel
+
+namespace ExpiryDate {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace ExpiryDate
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SmokeCoAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SmokeCoAlarm::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SmokeCoAlarm
+
+namespace DishwasherAlarm {
+namespace Attributes {
+
+namespace Mask {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Mask
+
+namespace Latch {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Latch
+
+namespace State {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace State
+
+namespace Supported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Supported
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DishwasherAlarm::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DishwasherAlarm
+
+namespace MicrowaveOvenMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MicrowaveOvenMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MicrowaveOvenMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MicrowaveOvenMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MicrowaveOvenMode
+
+namespace MicrowaveOvenControl {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MicrowaveOvenControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MicrowaveOvenControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MicrowaveOvenControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MicrowaveOvenControl
+
+namespace OperationalState {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OperationalState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OperationalState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OperationalState::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OperationalState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OperationalState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OperationalState::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OperationalState
+
+namespace RvcOperationalState {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RvcOperationalState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RvcOperationalState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RvcOperationalState::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RvcOperationalState::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RvcOperationalState::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RvcOperationalState::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcOperationalState
+
+namespace ScenesManagement {
+namespace Attributes {
+
+namespace LastConfiguredBy {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::NodeId> & value)
+{
+ using Traits = NumericAttributeTraits<chip::NodeId>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ScenesManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::NodeId value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::NodeId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ScenesManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_NODE_ID_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::NodeId value)
+{
+ using Traits = NumericAttributeTraits<chip::NodeId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ScenesManagement::Id, Id, writable, ZCL_NODE_ID_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::NodeId>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ScenesManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_NODE_ID_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::NodeId>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ScenesManagement::Id, Id, writable, ZCL_NODE_ID_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::NodeId> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::NodeId> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LastConfiguredBy
+
+namespace SceneTableSize {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ScenesManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ScenesManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ScenesManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SceneTableSize
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ScenesManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ScenesManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ScenesManagement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ScenesManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ScenesManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ScenesManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ScenesManagement
+
+namespace HepaFilterMonitoring {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::HepaFilterMonitoring::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::HepaFilterMonitoring::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::HepaFilterMonitoring::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace HepaFilterMonitoring
+
+namespace ActivatedCarbonFilterMonitoring {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ActivatedCarbonFilterMonitoring::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ActivatedCarbonFilterMonitoring::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ActivatedCarbonFilterMonitoring::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ActivatedCarbonFilterMonitoring
+
+namespace BooleanStateConfiguration {
+namespace Attributes {
+
+namespace SupportedSensitivityLevels {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SupportedSensitivityLevels
+
+namespace DefaultSensitivityLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace DefaultSensitivityLevel
+
+namespace AlarmsActive {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace AlarmsActive
+
+namespace AlarmsSuppressed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace AlarmsSuppressed
+
+namespace AlarmsEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace AlarmsEnabled
+
+namespace AlarmsSupported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace AlarmsSupported
+
+namespace SensorFault {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace SensorFault
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BooleanStateConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BooleanStateConfiguration::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BooleanStateConfiguration
+
+namespace ValveConfigurationAndControl {
+namespace Attributes {
+
+namespace OpenDuration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OpenDuration
+
+namespace DefaultOpenDuration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace DefaultOpenDuration
+
+namespace AutoCloseTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace AutoCloseTime
+
+namespace CurrentState {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentState
+
+namespace TargetState {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace TargetState
+
+namespace CurrentLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentLevel
+
+namespace TargetLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace TargetLevel
+
+namespace DefaultOpenLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::Percent * value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+} // namespace DefaultOpenLevel
+
+namespace ValveFault {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace ValveFault
+
+namespace LevelStep {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace LevelStep
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ValveConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ValveConfigurationAndControl
+
+namespace ElectricalPowerMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ElectricalPowerMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ElectricalPowerMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ElectricalPowerMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ElectricalPowerMeasurement
+
+namespace ElectricalEnergyMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ElectricalEnergyMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ElectricalEnergyMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ElectricalEnergyMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ElectricalEnergyMeasurement
+
+namespace WaterHeaterManagement {
+namespace Attributes {} // namespace Attributes
+} // namespace WaterHeaterManagement
+
+namespace DemandResponseLoadControl {
+namespace Attributes {
+
+namespace NumberOfLoadControlPrograms {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfLoadControlPrograms
+
+namespace NumberOfEventsPerProgram {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfEventsPerProgram
+
+namespace NumberOfTransitions {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfTransitions
+
+namespace DefaultRandomStart {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace DefaultRandomStart
+
+namespace DefaultRandomDuration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace DefaultRandomDuration
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DemandResponseLoadControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DemandResponseLoadControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DemandResponseLoadControl
+
+namespace Messages {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Messages::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Messages::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Messages::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Messages::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Messages::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Messages::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Messages
+
+namespace DeviceEnergyManagement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DeviceEnergyManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DeviceEnergyManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DeviceEnergyManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DeviceEnergyManagement
+
+namespace EnergyEvse {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EnergyEvse::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EnergyEvse::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EnergyEvse::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyEvse
+
+namespace EnergyPreference {
+namespace Attributes {
+
+namespace CurrentEnergyBalance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EnergyPreference::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EnergyPreference::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EnergyPreference::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentEnergyBalance
+
+namespace CurrentLowPowerModeSensitivity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EnergyPreference::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EnergyPreference::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EnergyPreference::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentLowPowerModeSensitivity
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EnergyPreference::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EnergyPreference::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EnergyPreference::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EnergyPreference::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EnergyPreference::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EnergyPreference::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyPreference
+
+namespace PowerTopology {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PowerTopology::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PowerTopology::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PowerTopology::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerTopology
+
+namespace EnergyEvseMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EnergyEvseMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EnergyEvseMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EnergyEvseMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyEvseMode
+
+namespace WaterHeaterMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WaterHeaterMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WaterHeaterMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WaterHeaterMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WaterHeaterMode
+
+namespace DeviceEnergyManagementMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DeviceEnergyManagementMode::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DeviceEnergyManagementMode::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DeviceEnergyManagementMode::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DeviceEnergyManagementMode
+
+namespace DoorLock {
+namespace Attributes {
+
+namespace LockState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockState>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockState value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockState>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockState value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockState>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockState>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockState>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LockState
+
+namespace LockType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockType>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockType>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DlLockType>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace LockType
+
+namespace ActuatorEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace ActuatorEnabled
+
+namespace DoorState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DoorStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DoorStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace DoorState
+
+namespace DoorOpenEvents {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace DoorOpenEvents
+
+namespace DoorClosedEvents {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace DoorClosedEvents
+
+namespace OpenPeriod {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace OpenPeriod
+
+namespace NumberOfTotalUsersSupported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfTotalUsersSupported
+
+namespace NumberOfPINUsersSupported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfPINUsersSupported
+
+namespace NumberOfRFIDUsersSupported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfRFIDUsersSupported
+
+namespace NumberOfWeekDaySchedulesSupportedPerUser {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfWeekDaySchedulesSupportedPerUser
+
+namespace NumberOfYearDaySchedulesSupportedPerUser {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfYearDaySchedulesSupportedPerUser
+
+namespace NumberOfHolidaySchedulesSupported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfHolidaySchedulesSupported
+
+namespace MaxPINCodeLength {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxPINCodeLength
+
+namespace MinPINCodeLength {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinPINCodeLength
+
+namespace MaxRFIDCodeLength {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxRFIDCodeLength
+
+namespace MinRFIDCodeLength {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinRFIDCodeLength
+
+namespace CredentialRulesSupport {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace CredentialRulesSupport
+
+namespace NumberOfCredentialsSupportedPerUser {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfCredentialsSupportedPerUser
+
+namespace Language {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[3 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 3, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 3);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(3 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 3, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[3 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(3 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 3, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[3 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace Language
+
+namespace LEDSettings {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace LEDSettings
+
+namespace AutoRelockTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace AutoRelockTime
+
+namespace SoundVolume {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SoundVolume
+
+namespace OperatingMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::OperatingModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::OperatingModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::DoorLock::OperatingModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace OperatingMode
+
+namespace SupportedOperatingModes {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace SupportedOperatingModes
+
+namespace DefaultConfigurationRegister {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace DefaultConfigurationRegister
+
+namespace EnableLocalProgramming {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnableLocalProgramming
+
+namespace EnableOneTouchLocking {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnableOneTouchLocking
+
+namespace EnableInsideStatusLED {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnableInsideStatusLED
+
+namespace EnablePrivacyModeButton {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnablePrivacyModeButton
+
+namespace LocalProgrammingFeatures {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace LocalProgrammingFeatures
+
+namespace WrongCodeEntryLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace WrongCodeEntryLimit
+
+namespace UserCodeTemporaryDisableTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace UserCodeTemporaryDisableTime
+
+namespace SendPINOverTheAir {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace SendPINOverTheAir
+
+namespace RequirePINforRemoteOperation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace RequirePINforRemoteOperation
+
+namespace ExpiringUserTimeout {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ExpiringUserTimeout
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::DoorLock::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::DoorLock::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::DoorLock::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DoorLock
+
+namespace WindowCovering {
+namespace Attributes {
+
+namespace Type {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::WindowCovering::Type * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::WindowCovering::Type>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::Type value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::WindowCovering::Type>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::Type value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::WindowCovering::Type>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Type
+
+namespace PhysicalClosedLimitLift {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PhysicalClosedLimitLift
+
+namespace PhysicalClosedLimitTilt {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PhysicalClosedLimitTilt
+
+namespace CurrentPositionLift {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentPositionLift
+
+namespace CurrentPositionTilt {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentPositionTilt
+
+namespace NumberOfActuationsLift {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfActuationsLift
+
+namespace NumberOfActuationsTilt {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfActuationsTilt
+
+namespace ConfigStatus {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ConfigStatus
+
+namespace CurrentPositionLiftPercentage {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentPositionLiftPercentage
+
+namespace CurrentPositionTiltPercentage {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentPositionTiltPercentage
+
+namespace OperationalStatus {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace OperationalStatus
+
+namespace TargetPositionLiftPercent100ths {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace TargetPositionLiftPercent100ths
+
+namespace TargetPositionTiltPercent100ths {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace TargetPositionTiltPercent100ths
+
+namespace EndProductType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::WindowCovering::EndProductType>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::WindowCovering::EndProductType>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::WindowCovering::EndProductType>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace EndProductType
+
+namespace CurrentPositionLiftPercent100ths {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentPositionLiftPercent100ths
+
+namespace CurrentPositionTiltPercent100ths {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent100ths>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_PERCENT100THS_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace CurrentPositionTiltPercent100ths
+
+namespace InstalledOpenLimitLift {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace InstalledOpenLimitLift
+
+namespace InstalledClosedLimitLift {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace InstalledClosedLimitLift
+
+namespace InstalledOpenLimitTilt {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace InstalledOpenLimitTilt
+
+namespace InstalledClosedLimitTilt {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace InstalledClosedLimitTilt
+
+namespace Mode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::Mode>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::Mode>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::Mode>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Mode
+
+namespace SafetyStatus {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace SafetyStatus
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WindowCovering::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WindowCovering::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WindowCovering::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WindowCovering
+
+namespace ServiceArea {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ServiceArea::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ServiceArea::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ServiceArea::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ServiceArea
+
+namespace PumpConfigurationAndControl {
+namespace Attributes {
+
+namespace MaxPressure {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxPressure
+
+namespace MaxSpeed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxSpeed
+
+namespace MaxFlow {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxFlow
+
+namespace MinConstPressure {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinConstPressure
+
+namespace MaxConstPressure {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxConstPressure
+
+namespace MinCompPressure {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinCompPressure
+
+namespace MaxCompPressure {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxCompPressure
+
+namespace MinConstSpeed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinConstSpeed
+
+namespace MaxConstSpeed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxConstSpeed
+
+namespace MinConstFlow {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinConstFlow
+
+namespace MaxConstFlow {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxConstFlow
+
+namespace MinConstTemp {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinConstTemp
+
+namespace MaxConstTemp {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxConstTemp
+
+namespace PumpStatus {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace PumpStatus
+
+namespace EffectiveOperationMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace EffectiveOperationMode
+
+namespace EffectiveControlMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace EffectiveControlMode
+
+namespace Capacity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Capacity
+
+namespace Speed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Speed
+
+namespace LifetimeRunningHours {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LifetimeRunningHours
+
+namespace Power {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Power
+
+namespace LifetimeEnergyConsumed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LifetimeEnergyConsumed
+
+namespace OperationMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace OperationMode
+
+namespace ControlMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ControlMode
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PumpConfigurationAndControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PumpConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PumpConfigurationAndControl
+
+namespace Thermostat {
+namespace Attributes {
+
+namespace LocalTemperature {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LocalTemperature
+
+namespace OutdoorTemperature {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OutdoorTemperature
+
+namespace Occupancy {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Occupancy
+
+namespace AbsMinHeatSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace AbsMinHeatSetpointLimit
+
+namespace AbsMaxHeatSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace AbsMaxHeatSetpointLimit
+
+namespace AbsMinCoolSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace AbsMinCoolSetpointLimit
+
+namespace AbsMaxCoolSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace AbsMaxCoolSetpointLimit
+
+namespace PICoolingDemand {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PICoolingDemand
+
+namespace PIHeatingDemand {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PIHeatingDemand
+
+namespace HVACSystemTypeConfiguration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace HVACSystemTypeConfiguration
+
+namespace LocalTemperatureCalibration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+} // namespace LocalTemperatureCalibration
+
+namespace OccupiedCoolingSetpoint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace OccupiedCoolingSetpoint
+
+namespace OccupiedHeatingSetpoint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace OccupiedHeatingSetpoint
+
+namespace UnoccupiedCoolingSetpoint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace UnoccupiedCoolingSetpoint
+
+namespace UnoccupiedHeatingSetpoint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace UnoccupiedHeatingSetpoint
+
+namespace MinHeatSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinHeatSetpointLimit
+
+namespace MaxHeatSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxHeatSetpointLimit
+
+namespace MinCoolSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinCoolSetpointLimit
+
+namespace MaxCoolSetpointLimit {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxCoolSetpointLimit
+
+namespace MinSetpointDeadBand {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinSetpointDeadBand
+
+namespace RemoteSensing {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace RemoteSensing
+
+namespace ControlSequenceOfOperation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ControlSequenceOfOperation
+
+namespace SystemMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::SystemModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::SystemModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SystemModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::SystemModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SystemModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::SystemModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace SystemMode
+
+namespace ThermostatRunningMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatRunningModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ThermostatRunningModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatRunningModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ThermostatRunningModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatRunningModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ThermostatRunningModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ThermostatRunningMode
+
+namespace StartOfWeek {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::StartOfWeekEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::StartOfWeekEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::StartOfWeekEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::StartOfWeekEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::StartOfWeekEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::StartOfWeekEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace StartOfWeek
+
+namespace NumberOfWeeklyTransitions {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfWeeklyTransitions
+
+namespace NumberOfDailyTransitions {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfDailyTransitions
+
+namespace TemperatureSetpointHold {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TemperatureSetpointHold
+
+namespace TemperatureSetpointHoldDuration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace TemperatureSetpointHoldDuration
+
+namespace ThermostatProgrammingOperationMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ThermostatProgrammingOperationMode
+
+namespace ThermostatRunningState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace ThermostatRunningState
+
+namespace SetpointChangeSource {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::SetpointChangeSourceEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::SetpointChangeSourceEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SetpointChangeSourceEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::SetpointChangeSourceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SetpointChangeSourceEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::SetpointChangeSourceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace SetpointChangeSource
+
+namespace SetpointChangeAmount {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SetpointChangeAmount
+
+namespace SetpointChangeSourceTimestamp {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace SetpointChangeSourceTimestamp
+
+namespace OccupiedSetback {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OccupiedSetback
+
+namespace OccupiedSetbackMin {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OccupiedSetbackMin
+
+namespace OccupiedSetbackMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace OccupiedSetbackMax
+
+namespace UnoccupiedSetback {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace UnoccupiedSetback
+
+namespace UnoccupiedSetbackMin {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace UnoccupiedSetbackMin
+
+namespace UnoccupiedSetbackMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace UnoccupiedSetbackMax
+
+namespace EmergencyHeatDelta {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace EmergencyHeatDelta
+
+namespace ACType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ACTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACType
+
+namespace ACCapacity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACCapacity
+
+namespace ACRefrigerantType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACRefrigerantType
+
+namespace ACCompressorType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCompressorTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACCompressorTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCompressorTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACCompressorTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCompressorTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACCompressorTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACCompressorType
+
+namespace ACErrorCode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACErrorCode
+
+namespace ACLouverPosition {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ACLouverPositionEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACLouverPositionEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACLouverPositionEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACLouverPositionEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACLouverPositionEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACLouverPositionEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACLouverPosition
+
+namespace ACCoilTemperature {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ACCoilTemperature
+
+namespace ACCapacityformat {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCapacityFormatEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACCapacityFormatEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCapacityFormatEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACCapacityFormatEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCapacityFormatEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Thermostat::ACCapacityFormatEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ACCapacityformat
+
+namespace NumberOfPresets {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfPresets
+
+namespace NumberOfSchedules {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfSchedules
+
+namespace NumberOfScheduleTransitions {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace NumberOfScheduleTransitions
+
+namespace NumberOfScheduleTransitionPerDay {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NumberOfScheduleTransitionPerDay
+
+namespace ActivePresetHandle {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ ChipLogError(Zcl, "Null Nullable<Span> passed to Thermostat::ActivePresetHandle::Get");
+ return Protocols::InteractionModel::Status::Failure;
+ }
+
+ uint8_t zclString[16 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ value.SetNull();
+ return Protocols::InteractionModel::Status::Success;
+ }
+ auto & span = value.Value();
+
+ VerifyOrReturnError(span.size() == 16, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(span.data(), &zclString[1], 16);
+ span.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ActivePresetHandle
+
+namespace ActiveScheduleHandle {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ ChipLogError(Zcl, "Null Nullable<Span> passed to Thermostat::ActiveScheduleHandle::Get");
+ return Protocols::InteractionModel::Status::Failure;
+ }
+
+ uint8_t zclString[16 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ value.SetNull();
+ return Protocols::InteractionModel::Status::Success;
+ }
+ auto & span = value.Value();
+
+ VerifyOrReturnError(span.size() == 16, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(span.data(), &zclString[1], 16);
+ span.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ActiveScheduleHandle
+
+namespace SetpointHoldExpiryTimestamp {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SetpointHoldExpiryTimestamp
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Thermostat::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Thermostat::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Thermostat::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Thermostat
+
+namespace FanControl {
+namespace Attributes {
+
+namespace FanMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::FanModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::FanModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::FanModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace FanMode
+
+namespace FanModeSequence {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::FanModeSequenceEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::FanModeSequenceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::FanModeSequenceEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace FanModeSequence
+
+namespace PercentSetting {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace PercentSetting
+
+namespace PercentCurrent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::Percent * value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_PERCENT_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value)
+{
+ using Traits = NumericAttributeTraits<chip::Percent>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE);
+}
+
+} // namespace PercentCurrent
+
+namespace SpeedMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SpeedMax
+
+namespace SpeedSetting {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SpeedSetting
+
+namespace SpeedCurrent {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SpeedCurrent
+
+namespace RockSupport {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace RockSupport
+
+namespace RockSetting {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace RockSetting
+
+namespace WindSupport {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace WindSupport
+
+namespace WindSetting {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace WindSetting
+
+namespace AirflowDirection {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::FanControl::AirflowDirectionEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::AirflowDirectionEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::AirflowDirectionEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::AirflowDirectionEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::AirflowDirectionEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::FanControl::AirflowDirectionEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace AirflowDirection
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FanControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FanControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FanControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FanControl
+
+namespace ThermostatUserInterfaceConfiguration {
+namespace Attributes {
+
+namespace TemperatureDisplayMode {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, writable,
+ ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TemperatureDisplayMode
+
+namespace KeypadLockout {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, writable,
+ ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace KeypadLockout
+
+namespace ScheduleProgrammingVisibility {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum * value)
+{
+ using Traits =
+ NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits =
+ NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum value)
+{
+ using Traits =
+ NumericAttributeTraits<chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, writable,
+ ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ScheduleProgrammingVisibility
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, writable,
+ ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThermostatUserInterfaceConfiguration::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThermostatUserInterfaceConfiguration
+
+namespace ColorControl {
+namespace Attributes {
+
+namespace CurrentHue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentHue
+
+namespace CurrentSaturation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentSaturation
+
+namespace RemainingTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace RemainingTime
+
+namespace CurrentX {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentX
+
+namespace CurrentY {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentY
+
+namespace DriftCompensation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::ColorControl::DriftCompensationEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::DriftCompensationEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::DriftCompensationEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::DriftCompensationEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::DriftCompensationEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::DriftCompensationEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace DriftCompensation
+
+namespace CompensationText {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[254 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 254, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 254);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(254 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 254, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[254 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(254 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 254, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[254 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace CompensationText
+
+namespace ColorTemperatureMireds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorTemperatureMireds
+
+namespace ColorMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::ColorControl::ColorModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::ColorModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::ColorModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::ColorModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::ColorModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::ColorModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorMode
+
+namespace Options {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Options
+
+namespace NumberOfPrimaries {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NumberOfPrimaries
+
+namespace Primary1X {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary1X
+
+namespace Primary1Y {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary1Y
+
+namespace Primary1Intensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Primary1Intensity
+
+namespace Primary2X {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary2X
+
+namespace Primary2Y {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary2Y
+
+namespace Primary2Intensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Primary2Intensity
+
+namespace Primary3X {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary3X
+
+namespace Primary3Y {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary3Y
+
+namespace Primary3Intensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Primary3Intensity
+
+namespace Primary4X {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary4X
+
+namespace Primary4Y {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary4Y
+
+namespace Primary4Intensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Primary4Intensity
+
+namespace Primary5X {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary5X
+
+namespace Primary5Y {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary5Y
+
+namespace Primary5Intensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Primary5Intensity
+
+namespace Primary6X {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary6X
+
+namespace Primary6Y {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Primary6Y
+
+namespace Primary6Intensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Primary6Intensity
+
+namespace WhitePointX {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace WhitePointX
+
+namespace WhitePointY {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace WhitePointY
+
+namespace ColorPointRX {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorPointRX
+
+namespace ColorPointRY {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorPointRY
+
+namespace ColorPointRIntensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ColorPointRIntensity
+
+namespace ColorPointGX {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorPointGX
+
+namespace ColorPointGY {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorPointGY
+
+namespace ColorPointGIntensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ColorPointGIntensity
+
+namespace ColorPointBX {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorPointBX
+
+namespace ColorPointBY {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorPointBY
+
+namespace ColorPointBIntensity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ColorPointBIntensity
+
+namespace EnhancedCurrentHue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnhancedCurrentHue
+
+namespace EnhancedColorMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::ColorControl::EnhancedColorModeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::EnhancedColorModeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::EnhancedColorModeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::EnhancedColorModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::EnhancedColorModeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ColorControl::EnhancedColorModeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnhancedColorMode
+
+namespace ColorLoopActive {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorLoopActive
+
+namespace ColorLoopDirection {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorLoopDirection
+
+namespace ColorLoopTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorLoopTime
+
+namespace ColorLoopStartEnhancedHue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorLoopStartEnhancedHue
+
+namespace ColorLoopStoredEnhancedHue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorLoopStoredEnhancedHue
+
+namespace ColorCapabilities {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorCapabilities
+
+namespace ColorTempPhysicalMinMireds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorTempPhysicalMinMireds
+
+namespace ColorTempPhysicalMaxMireds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ColorTempPhysicalMaxMireds
+
+namespace CoupleColorTempToLevelMinMireds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CoupleColorTempToLevelMinMireds
+
+namespace StartUpColorTemperatureMireds {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartUpColorTemperatureMireds
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ColorControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ColorControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ColorControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ColorControl
+
+namespace BallastConfiguration {
+namespace Attributes {
+
+namespace PhysicalMinLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PhysicalMinLevel
+
+namespace PhysicalMaxLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PhysicalMaxLevel
+
+namespace BallastStatus {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace BallastStatus
+
+namespace MinLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MinLevel
+
+namespace MaxLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxLevel
+
+namespace IntrinsicBallastFactor {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace IntrinsicBallastFactor
+
+namespace BallastFactorAdjustment {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace BallastFactorAdjustment
+
+namespace LampQuantity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace LampQuantity
+
+namespace LampType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[16 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 16, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 16);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace LampType
+
+namespace LampManufacturer {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[16 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 16, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 16);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace LampManufacturer
+
+namespace LampRatedHours {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LampRatedHours
+
+namespace LampBurnHours {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LampBurnHours
+
+namespace LampAlarmMode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace LampAlarmMode
+
+namespace LampBurnHoursTripPoint {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LampBurnHoursTripPoint
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::BallastConfiguration::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::BallastConfiguration::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BallastConfiguration
+
+namespace IlluminanceMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Tolerance
+
+namespace LightSensorType {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace LightSensorType
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::IlluminanceMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::IlluminanceMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace IlluminanceMeasurement
+
+namespace TemperatureMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_TEMPERATURE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Tolerance
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TemperatureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TemperatureMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TemperatureMeasurement
+
+namespace PressureMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Tolerance
+
+namespace ScaledValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace ScaledValue
+
+namespace MinScaledValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinScaledValue
+
+namespace MaxScaledValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxScaledValue
+
+namespace ScaledTolerance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ScaledTolerance
+
+namespace Scale {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Scale
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::PressureMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::PressureMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PressureMeasurement
+
+namespace FlowMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Tolerance
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FlowMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FlowMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FlowMeasurement
+
+namespace RelativeHumidityMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Tolerance
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RelativeHumidityMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RelativeHumidityMeasurement
+
+namespace OccupancySensing {
+namespace Attributes {
+
+namespace Occupancy {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap> value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Occupancy
+
+namespace OccupancySensorType {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace OccupancySensorType
+
+namespace OccupancySensorTypeBitmap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace OccupancySensorTypeBitmap
+
+namespace PIRUnoccupiedToOccupiedDelay {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PIRUnoccupiedToOccupiedDelay
+
+namespace PIRUnoccupiedToOccupiedThreshold {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PIRUnoccupiedToOccupiedThreshold
+
+namespace UltrasonicUnoccupiedToOccupiedDelay {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace UltrasonicUnoccupiedToOccupiedDelay
+
+namespace UltrasonicUnoccupiedToOccupiedThreshold {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace UltrasonicUnoccupiedToOccupiedThreshold
+
+namespace PhysicalContactUnoccupiedToOccupiedDelay {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PhysicalContactUnoccupiedToOccupiedDelay
+
+namespace PhysicalContactUnoccupiedToOccupiedThreshold {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace PhysicalContactUnoccupiedToOccupiedThreshold
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OccupancySensing::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OccupancySensing::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OccupancySensing::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OccupancySensing
+
+namespace CarbonMonoxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CarbonMonoxideConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CarbonMonoxideConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CarbonMonoxideConcentrationMeasurement::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CarbonMonoxideConcentrationMeasurement
+
+namespace CarbonDioxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CarbonDioxideConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CarbonDioxideConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CarbonDioxideConcentrationMeasurement::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CarbonDioxideConcentrationMeasurement
+
+namespace NitrogenDioxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::NitrogenDioxideConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::NitrogenDioxideConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::NitrogenDioxideConcentrationMeasurement::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace NitrogenDioxideConcentrationMeasurement
+
+namespace OzoneConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::OzoneConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::OzoneConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::OzoneConcentrationMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OzoneConcentrationMeasurement
+
+namespace Pm25ConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Pm25ConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Pm25ConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Pm25ConcentrationMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm25ConcentrationMeasurement
+
+namespace FormaldehydeConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FormaldehydeConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FormaldehydeConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FormaldehydeConcentrationMeasurement::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FormaldehydeConcentrationMeasurement
+
+namespace Pm1ConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Pm1ConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Pm1ConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Pm1ConcentrationMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm1ConcentrationMeasurement
+
+namespace Pm10ConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::Pm10ConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Pm10ConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Pm10ConcentrationMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm10ConcentrationMeasurement
+
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(
+ endpoint, Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(
+ ConcreteAttributePath(endpoint, Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+
+namespace RadonConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::RadonConcentrationMeasurement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::RadonConcentrationMeasurement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RadonConcentrationMeasurement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RadonConcentrationMeasurement
+
+namespace WiFiNetworkManagement {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WiFiNetworkManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WiFiNetworkManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WiFiNetworkManagement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WiFiNetworkManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WiFiNetworkManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WiFiNetworkManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WiFiNetworkManagement
+
+namespace ThreadBorderRouterManagement {
+namespace Attributes {
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThreadBorderRouterManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThreadBorderRouterManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThreadBorderRouterManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadBorderRouterManagement
+
+namespace ThreadNetworkDirectory {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThreadNetworkDirectory::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThreadNetworkDirectory::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThreadNetworkDirectory::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ThreadNetworkDirectory::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ThreadNetworkDirectory::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ThreadNetworkDirectory::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadNetworkDirectory
+
+namespace WakeOnLan {
+namespace Attributes {
+
+namespace MACAddress {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[12 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WakeOnLan::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 12, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 12);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(12 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 12, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[12 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WakeOnLan::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(12 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 12, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[12 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::WakeOnLan::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace MACAddress
+
+namespace LinkLocalAddress {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableByteSpan & value)
+{
+ uint8_t zclString[16 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WakeOnLan::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 16, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 16);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WakeOnLan::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(16 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 16, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[16 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::WakeOnLan::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace LinkLocalAddress
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WakeOnLan::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WakeOnLan::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WakeOnLan::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WakeOnLan::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WakeOnLan::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WakeOnLan::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WakeOnLan
+
+namespace Channel {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Channel::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Channel::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Channel::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Channel::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Channel::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Channel::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Channel
+
+namespace TargetNavigator {
+namespace Attributes {
+
+namespace CurrentTarget {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TargetNavigator::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TargetNavigator::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TargetNavigator::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentTarget
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TargetNavigator::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TargetNavigator::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TargetNavigator::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::TargetNavigator::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::TargetNavigator::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::TargetNavigator::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TargetNavigator
+
+namespace MediaPlayback {
+namespace Attributes {
+
+namespace CurrentState {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::MediaPlayback::PlaybackStateEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::MediaPlayback::PlaybackStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::MediaPlayback::PlaybackStateEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentState
+
+namespace StartTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace StartTime
+
+namespace Duration {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace Duration
+
+namespace PlaybackSpeed {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, float * value)
+{
+ using Traits = NumericAttributeTraits<float>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<float>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_SINGLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value)
+{
+ using Traits = NumericAttributeTraits<float>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE);
+}
+
+} // namespace PlaybackSpeed
+
+namespace SeekRangeEnd {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SeekRangeEnd
+
+namespace SeekRangeStart {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace SeekRangeStart
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaPlayback::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaPlayback::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaPlayback::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MediaPlayback
+
+namespace MediaInput {
+namespace Attributes {
+
+namespace CurrentInput {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaInput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaInput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaInput::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentInput
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaInput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaInput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaInput::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::MediaInput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::MediaInput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::MediaInput::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MediaInput
+
+namespace LowPower {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::LowPower::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LowPower::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LowPower::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::LowPower::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::LowPower::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::LowPower::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LowPower
+
+namespace KeypadInput {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::KeypadInput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::KeypadInput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::KeypadInput::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::KeypadInput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::KeypadInput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::KeypadInput::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace KeypadInput
+
+namespace ContentLauncher {
+namespace Attributes {
+
+namespace SupportedStreamingProtocols {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentLauncher::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentLauncher::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentLauncher::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace SupportedStreamingProtocols
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentLauncher::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentLauncher::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentLauncher::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentLauncher::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentLauncher::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentLauncher::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentLauncher
+
+namespace AudioOutput {
+namespace Attributes {
+
+namespace CurrentOutput {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AudioOutput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AudioOutput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AudioOutput::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentOutput
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AudioOutput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AudioOutput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AudioOutput::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AudioOutput::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AudioOutput::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AudioOutput::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AudioOutput
+
+namespace ApplicationLauncher {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationLauncher::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationLauncher::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationLauncher::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationLauncher::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationLauncher::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationLauncher::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ApplicationLauncher
+
+namespace ApplicationBasic {
+namespace Attributes {
+
+namespace VendorName {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace VendorName
+
+namespace VendorID {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::VendorId * value)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_VENDOR_ID_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, writable, ZCL_VENDOR_ID_ATTRIBUTE_TYPE);
+}
+
+} // namespace VendorID
+
+namespace ApplicationName {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[256 + 2];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfLongStringLength(zclString);
+ if (length == NumericAttributeTraits<uint16_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 256, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[2], 256);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(256 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 256, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[256 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(256 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 256, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[256 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ApplicationName
+
+namespace ProductID {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ProductID
+
+namespace Status {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Status
+
+namespace ApplicationVersion {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[32 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 32, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 32);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(32 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 32, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[32 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ApplicationVersion
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ApplicationBasic::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ApplicationBasic::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ApplicationBasic
+
+namespace AccountLogin {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AccountLogin::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AccountLogin::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AccountLogin::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::AccountLogin::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::AccountLogin::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::AccountLogin::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AccountLogin
+
+namespace ContentControl {
+namespace Attributes {
+
+namespace Enabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace Enabled
+
+namespace OnDemandRatingThreshold {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[8 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 8, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 8);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(8 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 8, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[8 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(8 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 8, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[8 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace OnDemandRatingThreshold
+
+namespace ScheduledContentRatingThreshold {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[8 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 8, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 8);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(8 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 8, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[8 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(8 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 8, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[8 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace ScheduledContentRatingThreshold
+
+namespace ScreenDailyTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace ScreenDailyTime
+
+namespace RemainingScreenTime {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace RemainingScreenTime
+
+namespace BlockUnrated {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace BlockUnrated
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentControl
+
+namespace ContentAppObserver {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentAppObserver::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentAppObserver::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentAppObserver::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ContentAppObserver::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ContentAppObserver::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ContentAppObserver::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentAppObserver
+
+namespace ZoneManagement {
+namespace Attributes {
+
+namespace Sensitivity {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ZoneManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ZoneManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ZoneManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Sensitivity
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ZoneManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ZoneManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ZoneManagement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::ZoneManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::ZoneManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::ZoneManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ZoneManagement
+
+namespace CameraAvStreamManagement {
+namespace Attributes {
+
+namespace MaxConcurrentVideoEncoders {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxConcurrentVideoEncoders
+
+namespace MaxEncodedPixelRate {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxEncodedPixelRate
+
+namespace NightVisionCapable {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace NightVisionCapable
+
+namespace MaxContentBufferSize {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxContentBufferSize
+
+namespace TwoWayTalkSupport {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace TwoWayTalkSupport
+
+namespace MaxNetworkBandwidth {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxNetworkBandwidth
+
+namespace CurrentFrameRate {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace CurrentFrameRate
+
+namespace HDRModeEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace HDRModeEnabled
+
+namespace SoftRecordingPrivacyModeEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace SoftRecordingPrivacyModeEnabled
+
+namespace SoftLivestreamPrivacyModeEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace SoftLivestreamPrivacyModeEnabled
+
+namespace HardPrivacyModeOn {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace HardPrivacyModeOn
+
+namespace NightVision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace NightVision
+
+namespace NightVisionIllum {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace NightVisionIllum
+
+namespace SpeakerMuted {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace SpeakerMuted
+
+namespace SpeakerVolumeLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SpeakerVolumeLevel
+
+namespace SpeakerMaxLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SpeakerMaxLevel
+
+namespace SpeakerMinLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace SpeakerMinLevel
+
+namespace MicrophoneMuted {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace MicrophoneMuted
+
+namespace MicrophoneVolumeLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MicrophoneVolumeLevel
+
+namespace MicrophoneMaxLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MicrophoneMaxLevel
+
+namespace MicrophoneMinLevel {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MicrophoneMinLevel
+
+namespace MicrophoneAGCEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace MicrophoneAGCEnabled
+
+namespace ImageRotation {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ImageRotation
+
+namespace ImageFlipHorizontal {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace ImageFlipHorizontal
+
+namespace ImageFlipVertical {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace ImageFlipVertical
+
+namespace LocalVideoRecordingEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace LocalVideoRecordingEnabled
+
+namespace LocalSnapshotRecordingEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace LocalSnapshotRecordingEnabled
+
+namespace StatusLightEnabled {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace StatusLightEnabled
+
+namespace StatusLightBrightness {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Globals::ThreeLevelAutoEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::ThreeLevelAutoEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::ThreeLevelAutoEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::ThreeLevelAutoEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::ThreeLevelAutoEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::ThreeLevelAutoEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace StatusLightBrightness
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvStreamManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvStreamManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CameraAvStreamManagement
+
+namespace CameraAvSettingsUserLevelManagement {
+namespace Attributes {
+
+namespace MaxPresets {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MaxPresets
+
+namespace ZoomMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ZoomMax
+
+namespace TiltMin {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+} // namespace TiltMin
+
+namespace TiltMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+} // namespace TiltMax
+
+namespace PanMin {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+} // namespace PanMin
+
+namespace PanMax {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+} // namespace PanMax
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CameraAvSettingsUserLevelManagement::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CameraAvSettingsUserLevelManagement
+
+namespace WebRTCTransportProvider {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WebRTCTransportProvider::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WebRTCTransportProvider::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WebRTCTransportProvider::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WebRTCTransportProvider::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WebRTCTransportProvider::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WebRTCTransportProvider::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WebRTCTransportProvider
+
+namespace WebRTCTransportRequestor {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WebRTCTransportRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WebRTCTransportRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WebRTCTransportRequestor::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::WebRTCTransportRequestor::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::WebRTCTransportRequestor::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::WebRTCTransportRequestor::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WebRTCTransportRequestor
+
+namespace Chime {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Chime::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Chime::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Chime::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Chime::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Chime::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::Chime::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Chime
+
+namespace EcosystemInformation {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EcosystemInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EcosystemInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EcosystemInformation::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::EcosystemInformation::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::EcosystemInformation::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::EcosystemInformation::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EcosystemInformation
+
+namespace CommissionerControl {
+namespace Attributes {
+
+namespace SupportedDeviceCategories {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CommissionerControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CommissionerControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CommissionerControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace SupportedDeviceCategories
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CommissionerControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CommissionerControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CommissionerControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::CommissionerControl::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::CommissionerControl::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::CommissionerControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CommissionerControl
+
+namespace UnitTesting {
+namespace Attributes {
+
+namespace Boolean {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace Boolean
+
+namespace Bitmap8 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Bitmap8
+
+namespace Bitmap16 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+} // namespace Bitmap16
+
+namespace Bitmap32 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Bitmap32
+
+namespace Bitmap64 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP64_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP64_ATTRIBUTE_TYPE);
+}
+
+} // namespace Bitmap64
+
+namespace Int8u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int8u
+
+namespace Int16u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int16u
+
+namespace Int24u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int24u
+
+namespace Int32u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int32u
+
+namespace Int40u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT40U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT40U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int40u
+
+namespace Int48u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT48U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT48U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int48u
+
+namespace Int56u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT56U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT56U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int56u
+
+namespace Int64u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int64u
+
+namespace Int8s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int8s
+
+namespace Int16s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int16s
+
+namespace Int24s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int32_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT24S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int24s
+
+namespace Int32s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int32_t * value)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int32s
+
+namespace Int40s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT40S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT40S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int40s
+
+namespace Int48s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT48S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT48S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int48s
+
+namespace Int56s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT56S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT56S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int56s
+
+namespace Int64s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE);
+}
+
+} // namespace Int64s
+
+namespace Enum8 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace Enum8
+
+namespace Enum16 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+} // namespace Enum16
+
+namespace FloatSingle {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, float * value)
+{
+ using Traits = NumericAttributeTraits<float>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<float>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_SINGLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value)
+{
+ using Traits = NumericAttributeTraits<float>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE);
+}
+
+} // namespace FloatSingle
+
+namespace FloatDouble {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, double * value)
+{
+ using Traits = NumericAttributeTraits<double>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<double>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_DOUBLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value)
+{
+ using Traits = NumericAttributeTraits<double>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_DOUBLE_ATTRIBUTE_TYPE);
+}
+
+} // namespace FloatDouble
+
+namespace OctetString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableByteSpan & value)
+{
+ uint8_t zclString[10 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 10, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 10);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace OctetString
+
+namespace LongOctetString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableByteSpan & value)
+{
+ uint8_t zclString[1000 + 2];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfLongStringLength(zclString);
+ if (length == NumericAttributeTraits<uint16_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 1000, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[2], 1000);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(1000 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 1000, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[1000 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(1000 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 1000, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[1000 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace LongOctetString
+
+namespace CharString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[10 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 10, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[1], 10);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace CharString
+
+namespace LongCharString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value)
+{
+ uint8_t zclString[1000 + 2];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfLongStringLength(zclString);
+ if (length == NumericAttributeTraits<uint16_t>::kNullValue)
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+
+ VerifyOrReturnError(value.size() == 1000, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(value.data(), &zclString[2], 1000);
+ value.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(1000 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 1000, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[1000 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(1000 < NumericAttributeTraits<uint16_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 1000, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[1000 + 2];
+ auto length = static_cast<uint16_t>(value.size());
+ Encoding::LittleEndian::Put16(zclString, length);
+ memcpy(&zclString[2], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+} // namespace LongCharString
+
+namespace EpochUs {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE);
+}
+
+} // namespace EpochUs
+
+namespace EpochS {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_EPOCH_S_ATTRIBUTE_TYPE);
+}
+
+} // namespace EpochS
+
+namespace VendorId {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::VendorId * value)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_VENDOR_ID_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value)
+{
+ using Traits = NumericAttributeTraits<chip::VendorId>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_VENDOR_ID_ATTRIBUTE_TYPE);
+}
+
+} // namespace VendorId
+
+namespace EnumAttr {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace EnumAttr
+
+namespace RangeRestrictedInt8u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace RangeRestrictedInt8u
+
+namespace RangeRestrictedInt8s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+} // namespace RangeRestrictedInt8s
+
+namespace RangeRestrictedInt16u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace RangeRestrictedInt16u
+
+namespace RangeRestrictedInt16s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+} // namespace RangeRestrictedInt16s
+
+namespace TimedWriteBoolean {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace TimedWriteBoolean
+
+namespace GlobalEnum {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum * value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+} // namespace GlobalEnum
+
+namespace Unsupported {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace Unsupported
+
+namespace ReadFailureCode {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ReadFailureCode
+
+namespace FailureInt32U {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+} // namespace FailureInt32U
+
+namespace NullableBoolean {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<bool> & value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<bool> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<bool> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableBoolean
+
+namespace NullableBitmap8 {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> & value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableBitmap8
+
+namespace NullableBitmap16 {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> & value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableBitmap16
+
+namespace NullableBitmap32 {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> & value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableBitmap32
+
+namespace NullableBitmap64 {
+
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> & value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP64_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP64_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP64_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP64_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableBitmap64
+
+namespace NullableInt8u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt8u
+
+namespace NullableInt16u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt16u
+
+namespace NullableInt24u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt24u
+
+namespace NullableInt32u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt32u
+
+namespace NullableInt40u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT40U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT40U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT40U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT40U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt40u
+
+namespace NullableInt48u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT48U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT48U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT48U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT48U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt48u
+
+namespace NullableInt56u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT56U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT56U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT56U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, false>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT56U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt56u
+
+namespace NullableInt64u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt64u
+
+namespace NullableInt8s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int8_t> & value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt8s
+
+namespace NullableInt16s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt16s
+
+namespace NullableInt24s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int32_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT24S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT24S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<3, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT24S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt24s
+
+namespace NullableInt32s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int32_t> & value)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT32S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int32_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt32s
+
+namespace NullableInt40s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT40S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT40S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT40S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<5, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT40S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt40s
+
+namespace NullableInt48s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT48S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT48S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT48S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<6, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT48S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt48s
+
+namespace NullableInt56s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT56S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT56S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT56S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<OddSizedInteger<7, true>>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT56S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt56s
+
+namespace NullableInt64s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT64S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int64_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableInt64s
+
+namespace NullableEnum8 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableEnum8
+
+namespace NullableEnum16 {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM16_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableEnum16
+
+namespace NullableFloatSingle {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<float> & value)
+{
+ using Traits = NumericAttributeTraits<float>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<float>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_SINGLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value)
+{
+ using Traits = NumericAttributeTraits<float>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<float>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_SINGLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<float>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<float> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<float> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableFloatSingle
+
+namespace NullableFloatDouble {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<double> & value)
+{
+ using Traits = NumericAttributeTraits<double>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<double>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_DOUBLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value)
+{
+ using Traits = NumericAttributeTraits<double>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_DOUBLE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<double>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_DOUBLE_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<double>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_DOUBLE_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<double> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<double> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableFloatDouble
+
+namespace NullableOctetString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ ChipLogError(Zcl, "Null Nullable<Span> passed to UnitTesting::NullableOctetString::Get");
+ return Protocols::InteractionModel::Status::Failure;
+ }
+
+ uint8_t zclString[10 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ value.SetNull();
+ return Protocols::InteractionModel::Status::Success;
+ }
+ auto & span = value.Value();
+
+ VerifyOrReturnError(span.size() == 10, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(span.data(), &zclString[1], 10);
+ span.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableOctetString
+
+namespace NullableCharString {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableCharSpan> & value)
+{
+ if (value.IsNull())
+ {
+ ChipLogError(Zcl, "Null Nullable<Span> passed to UnitTesting::NullableCharString::Get");
+ return Protocols::InteractionModel::Status::Failure;
+ }
+
+ uint8_t zclString[10 + 1];
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, sizeof(zclString));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ size_t length = emberAfStringLength(zclString);
+ if (length == NumericAttributeTraits<uint8_t>::kNullValue)
+ {
+ value.SetNull();
+ return Protocols::InteractionModel::Status::Success;
+ }
+ auto & span = value.Value();
+
+ VerifyOrReturnError(span.size() == 10, Protocols::InteractionModel::Status::InvalidDataType);
+ memcpy(span.data(), &zclString[1], 10);
+ span.reduce_size(length);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value)
+{
+
+ static_assert(10 < NumericAttributeTraits<uint8_t>::kNullValue, "value.size() might be too big");
+ VerifyOrReturnError(value.size() <= 10, Protocols::InteractionModel::Status::ConstraintError);
+ uint8_t zclString[10 + 1];
+ auto length = static_cast<uint8_t>(value.size());
+ Encoding::Put8(zclString, length);
+ memcpy(&zclString[1], value.data(), value.size());
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ uint8_t zclString[1] = { 0xFF };
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::CharSpan> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::CharSpan> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableCharString
+
+namespace NullableEnumAttr {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableEnumAttr
+
+namespace NullableRangeRestrictedInt8u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableRangeRestrictedInt8u
+
+namespace NullableRangeRestrictedInt8s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int8_t> & value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int8_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableRangeRestrictedInt8s
+
+namespace NullableRangeRestrictedInt16u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableRangeRestrictedInt16u
+
+namespace NullableRangeRestrictedInt16s {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16S_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<int16_t>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableRangeRestrictedInt16s
+
+namespace WriteOnlyInt8u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace WriteOnlyInt8u
+
+namespace NullableGlobalEnum {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> & value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (Traits::IsNullValue(temp))
+ {
+ value.SetNull();
+ }
+ else
+ {
+ value.SetNonNull() = Traits::StorageToWorking(temp);
+ }
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value,
+ MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ true, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_ENUM8_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint)
+{
+ using Traits = NumericAttributeTraits<chip::app::Clusters::Globals::TestGlobalEnum>;
+ Traits::StorageType value;
+ Traits::SetNull(value);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> & value,
+ MarkAttributeDirty markDirty)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint, markDirty);
+ }
+
+ return Set(endpoint, value.Value(), markDirty);
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> & value)
+{
+ if (value.IsNull())
+ {
+ return SetNull(endpoint);
+ }
+
+ return Set(endpoint, value.Value());
+}
+
+} // namespace NullableGlobalEnum
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+namespace MeiInt8u {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::UnitTesting::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::UnitTesting::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value)
+{
+ using Traits = NumericAttributeTraits<uint8_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::UnitTesting::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE);
+}
+
+} // namespace MeiInt8u
+
+} // namespace Attributes
+} // namespace UnitTesting
+
+namespace FaultInjection {
+namespace Attributes {
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FaultInjection::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FaultInjection::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FaultInjection::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::FaultInjection::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::FaultInjection::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::FaultInjection::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FaultInjection
+
+namespace SampleManufacturerSpecific {
+namespace Attributes {
+
+namespace FlipFlop {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleManufacturerSpecific::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace FlipFlop
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleManufacturerSpecific::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleManufacturerSpecific::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SampleManufacturerSpecific
+
+namespace SampleExternalManufacturerSpecific {
+namespace Attributes {
+
+namespace FlipFlop {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
+{
+ using Traits = NumericAttributeTraits<bool>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id, writable,
+ ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+}
+
+} // namespace FlipFlop
+
+namespace FeatureMap {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id, writable,
+ ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ Protocols::InteractionModel::Status status =
+ emberAfReadAttribute(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id),
+ EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
+}
+
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return Protocols::InteractionModel::Status::ConstraintError;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleExternalManufacturerSpecific::Id, Id, writable,
+ ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
new file mode 100644
index 00000000000000..584dc0084a2ecc
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
@@ -0,0 +1,6702 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+/**
+ * @file
+ * This file contains declarations for accessors around clusters attributes.
+ */
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/data-model/Nullable.h>
+#include <app/util/af-types.h>
+#include <app/util/ember-strings.h>
+#include <lib/support/Span.h>
+#include <protocols/interaction_model/StatusCode.h>
+
+namespace chip {
+namespace app {
+
+namespace Clusters {
+
+namespace Identify {
+namespace Attributes {
+
+namespace IdentifyTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace IdentifyTime
+
+namespace IdentifyType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Identify::IdentifyTypeEnum * value); // IdentifyTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Identify::IdentifyTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Identify::IdentifyTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace IdentifyType
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Identify
+
+namespace Groups {
+namespace Attributes {
+
+namespace NameSupport {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap> * value); // NameSupportBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace NameSupport
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Groups
+
+namespace OnOff {
+namespace Attributes {
+
+namespace OnOff {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace OnOff
+
+namespace GlobalSceneControl {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace GlobalSceneControl
+
+namespace OnTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace OnTime
+
+namespace OffWaitTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace OffWaitTime
+
+namespace StartUpOnOff {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> & value); // StartUpOnOffEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OnOff::StartUpOnOffEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OnOff::StartUpOnOffEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpOnOff
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OnOff
+
+namespace LevelControl {
+namespace Attributes {
+
+namespace CurrentLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentLevel
+
+namespace RemainingTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace RemainingTime
+
+namespace MinLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MinLevel
+
+namespace MaxLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxLevel
+
+namespace CurrentFrequency {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentFrequency
+
+namespace MinFrequency {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace MinFrequency
+
+namespace MaxFrequency {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace MaxFrequency
+
+namespace Options {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap> * value); // OptionsBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Options
+
+namespace OnOffTransitionTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace OnOffTransitionTime
+
+namespace OnLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnLevel
+
+namespace OnTransitionTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnTransitionTime
+
+namespace OffTransitionTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OffTransitionTime
+
+namespace DefaultMoveRate {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace DefaultMoveRate
+
+namespace StartUpCurrentLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpCurrentLevel
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LevelControl
+
+namespace PulseWidthModulation {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PulseWidthModulation
+
+namespace Descriptor {
+namespace Attributes {} // namespace Attributes
+} // namespace Descriptor
+
+namespace Binding {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Binding
+
+namespace AccessControl {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+} // namespace Attributes
+} // namespace AccessControl
+
+namespace Actions {
+namespace Attributes {
+
+namespace SetupURL {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // long_char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace SetupURL
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Actions
+
+namespace BasicInformation {
+namespace Attributes {
+
+namespace NodeLabel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace NodeLabel
+
+namespace LocalConfigDisabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace LocalConfigDisabled
+
+namespace Reachable {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace Reachable
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BasicInformation
+
+namespace OtaSoftwareUpdateProvider {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateProvider
+
+namespace OtaSoftwareUpdateRequestor {
+namespace Attributes {
+
+namespace UpdatePossible {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace UpdatePossible
+
+namespace UpdateState {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum * value); // UpdateStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace UpdateState
+
+namespace UpdateStateProgress {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace UpdateStateProgress
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateRequestor
+
+namespace LocalizationConfiguration {
+namespace Attributes {
+
+namespace ActiveLocale {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ActiveLocale
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LocalizationConfiguration
+
+namespace TimeFormatLocalization {
+namespace Attributes {
+
+namespace HourFormat {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::TimeFormatLocalization::HourFormatEnum * value); // HourFormatEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace HourFormat
+
+namespace ActiveCalendarType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum * value); // CalendarTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ActiveCalendarType
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TimeFormatLocalization
+
+namespace UnitLocalization {
+namespace Attributes {
+
+namespace TemperatureUnit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::UnitLocalization::TempUnitEnum * value); // TempUnitEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TemperatureUnit
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace UnitLocalization
+
+namespace PowerSourceConfiguration {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerSourceConfiguration
+
+namespace PowerSource {
+namespace Attributes {
+
+namespace Status {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PowerSource::PowerSourceStatusEnum * value); // PowerSourceStatusEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::PowerSourceStatusEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::PowerSourceStatusEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace Status
+
+namespace Order {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace Order
+
+namespace Description {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace Description
+
+namespace WiredAssessedInputVoltage {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace WiredAssessedInputVoltage
+
+namespace WiredAssessedInputFrequency {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace WiredAssessedInputFrequency
+
+namespace WiredCurrentType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PowerSource::WiredCurrentTypeEnum * value); // WiredCurrentTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::WiredCurrentTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::WiredCurrentTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace WiredCurrentType
+
+namespace WiredAssessedCurrent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace WiredAssessedCurrent
+
+namespace WiredNominalVoltage {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace WiredNominalVoltage
+
+namespace WiredMaximumCurrent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace WiredMaximumCurrent
+
+namespace WiredPresent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace WiredPresent
+
+namespace BatVoltage {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace BatVoltage
+
+namespace BatPercentRemaining {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace BatPercentRemaining
+
+namespace BatTimeRemaining {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace BatTimeRemaining
+
+namespace BatChargeLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PowerSource::BatChargeLevelEnum * value); // BatChargeLevelEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace BatChargeLevel
+
+namespace BatReplacementNeeded {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace BatReplacementNeeded
+
+namespace BatReplaceability {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PowerSource::BatReplaceabilityEnum * value); // BatReplaceabilityEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatReplaceabilityEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatReplaceabilityEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace BatReplaceability
+
+namespace BatPresent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace BatPresent
+
+namespace BatReplacementDescription {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace BatReplacementDescription
+
+namespace BatCommonDesignation {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum * value); // BatCommonDesignationEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace BatCommonDesignation
+
+namespace BatANSIDesignation {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace BatANSIDesignation
+
+namespace BatIECDesignation {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace BatIECDesignation
+
+namespace BatApprovedChemistry {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum * value); // BatApprovedChemistryEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace BatApprovedChemistry
+
+namespace BatCapacity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace BatCapacity
+
+namespace BatQuantity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace BatQuantity
+
+namespace BatChargeState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::PowerSource::BatChargeStateEnum * value); // BatChargeStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace BatChargeState
+
+namespace BatTimeToFullCharge {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace BatTimeToFullCharge
+
+namespace BatFunctionalWhileCharging {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace BatFunctionalWhileCharging
+
+namespace BatChargingCurrent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace BatChargingCurrent
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerSource
+
+namespace GeneralCommissioning {
+namespace Attributes {
+
+namespace Breadcrumb {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value); // int64u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+} // namespace Breadcrumb
+
+namespace TCAcceptedVersion {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace TCAcceptedVersion
+
+namespace TCMinRequiredVersion {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace TCMinRequiredVersion
+
+namespace TCAcknowledgements {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // bitmap16
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace TCAcknowledgements
+
+namespace TCAcknowledgementsRequired {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace TCAcknowledgementsRequired
+
+namespace TCUpdateDeadline {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace TCUpdateDeadline
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace GeneralCommissioning
+
+namespace NetworkCommissioning {
+namespace Attributes {
+
+namespace MaxNetworks {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxNetworks
+
+namespace ScanMaxTimeSeconds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace ScanMaxTimeSeconds
+
+namespace ConnectMaxTimeSeconds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace ConnectMaxTimeSeconds
+
+namespace InterfaceEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace InterfaceEnabled
+
+namespace LastNetworkingStatus {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> &
+ value); // NetworkCommissioningStatusEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LastNetworkingStatus
+
+namespace LastNetworkID {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value); // octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LastNetworkID
+
+namespace LastConnectErrorValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int32_t> & value); // int32s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LastConnectErrorValue
+
+namespace SupportedThreadFeatures {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap> * value); // ThreadCapabilitiesBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace SupportedThreadFeatures
+
+namespace ThreadVersion {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ThreadVersion
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace NetworkCommissioning
+
+namespace DiagnosticLogs {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DiagnosticLogs
+
+namespace GeneralDiagnostics {
+namespace Attributes {
+
+namespace TestEventTriggersEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace TestEventTriggersEnabled
+
+} // namespace Attributes
+} // namespace GeneralDiagnostics
+
+namespace SoftwareDiagnostics {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SoftwareDiagnostics
+
+namespace ThreadNetworkDiagnostics {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadNetworkDiagnostics
+
+namespace WiFiNetworkDiagnostics {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WiFiNetworkDiagnostics
+
+namespace EthernetNetworkDiagnostics {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EthernetNetworkDiagnostics
+
+namespace TimeSynchronization {
+namespace Attributes {
+
+namespace TimeSource {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::TimeSynchronization::TimeSourceEnum * value); // TimeSourceEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TimeSource
+
+namespace TimeZoneDatabase {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum * value); // TimeZoneDatabaseEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TimeZoneDatabase
+
+namespace NTPServerAvailable {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace NTPServerAvailable
+
+namespace SupportsDNSResolve {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace SupportsDNSResolve
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TimeSynchronization
+
+namespace BridgedDeviceBasicInformation {
+namespace Attributes {
+
+namespace VendorName {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace VendorName
+
+namespace VendorID {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::VendorId * value); // vendor_id
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value, MarkAttributeDirty markDirty);
+} // namespace VendorID
+
+namespace ProductName {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ProductName
+
+namespace ProductID {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ProductID
+
+namespace NodeLabel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace NodeLabel
+
+namespace HardwareVersion {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace HardwareVersion
+
+namespace HardwareVersionString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace HardwareVersionString
+
+namespace SoftwareVersion {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace SoftwareVersion
+
+namespace SoftwareVersionString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace SoftwareVersionString
+
+namespace ManufacturingDate {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ManufacturingDate
+
+namespace PartNumber {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace PartNumber
+
+namespace ProductURL {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // long_char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ProductURL
+
+namespace ProductLabel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ProductLabel
+
+namespace SerialNumber {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace SerialNumber
+
+namespace Reachable {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace Reachable
+
+namespace UniqueID {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace UniqueID
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BridgedDeviceBasicInformation
+
+namespace Switch {
+namespace Attributes {
+
+namespace NumberOfPositions {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfPositions
+
+namespace CurrentPosition {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentPosition
+
+namespace MultiPressMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MultiPressMax
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Switch
+
+namespace AdministratorCommissioning {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AdministratorCommissioning
+
+namespace OperationalCredentials {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OperationalCredentials
+
+namespace GroupKeyManagement {
+namespace Attributes {} // namespace Attributes
+} // namespace GroupKeyManagement
+
+namespace FixedLabel {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FixedLabel
+
+namespace UserLabel {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace UserLabel
+
+namespace ProxyConfiguration {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyConfiguration
+
+namespace ProxyDiscovery {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyDiscovery
+
+namespace ProxyValid {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyValid
+
+namespace BooleanState {
+namespace Attributes {
+
+namespace StateValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace StateValue
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BooleanState
+
+namespace IcdManagement {
+namespace Attributes {
+
+namespace UserActiveModeTriggerHint {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap> * value); // UserActiveModeTriggerBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace UserActiveModeTriggerHint
+
+namespace UserActiveModeTriggerInstruction {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace UserActiveModeTriggerInstruction
+
+namespace OperatingMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::IcdManagement::OperatingModeEnum * value); // OperatingModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IcdManagement::OperatingModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IcdManagement::OperatingModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace OperatingMode
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace IcdManagement
+
+namespace Timer {
+namespace Attributes {
+
+namespace SetTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // elapsed_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace SetTime
+
+namespace TimeRemaining {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // elapsed_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace TimeRemaining
+
+namespace TimerState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Timer::TimerStatusEnum * value); // TimerStatusEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Timer::TimerStatusEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Timer::TimerStatusEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TimerState
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Timer
+
+namespace OvenCavityOperationalState {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OvenCavityOperationalState
+
+namespace OvenMode {
+namespace Attributes {
+
+namespace CurrentMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentMode
+
+namespace StartUpMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpMode
+
+namespace OnMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnMode
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OvenMode
+
+namespace LaundryDryerControls {
+namespace Attributes {
+
+namespace SelectedDrynessLevel {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> & value); // DrynessLevelEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SelectedDrynessLevel
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryDryerControls
+
+namespace ModeSelect {
+namespace Attributes {
+
+namespace Description {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace Description
+
+namespace StandardNamespace {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // enum16
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StandardNamespace
+
+namespace CurrentMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentMode
+
+namespace StartUpMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpMode
+
+namespace OnMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnMode
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ModeSelect
+
+namespace LaundryWasherMode {
+namespace Attributes {
+
+namespace StartUpMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpMode
+
+namespace OnMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnMode
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryWasherMode
+
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+namespace Attributes {
+
+namespace StartUpMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpMode
+
+namespace OnMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnMode
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+
+namespace LaundryWasherControls {
+namespace Attributes {
+
+namespace SpinSpeedCurrent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SpinSpeedCurrent
+
+namespace NumberOfRinses {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum * value); // NumberOfRinsesEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace NumberOfRinses
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryWasherControls
+
+namespace RvcRunMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcRunMode
+
+namespace RvcCleanMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcCleanMode
+
+namespace TemperatureControl {
+namespace Attributes {
+
+namespace TemperatureSetpoint {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace TemperatureSetpoint
+
+namespace MinTemperature {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace MinTemperature
+
+namespace MaxTemperature {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace MaxTemperature
+
+namespace Step {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace Step
+
+namespace SelectedTemperatureLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SelectedTemperatureLevel
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TemperatureControl
+
+namespace RefrigeratorAlarm {
+namespace Attributes {
+
+namespace Mask {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value, MarkAttributeDirty markDirty);
+} // namespace Mask
+
+namespace State {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value, MarkAttributeDirty markDirty);
+} // namespace State
+
+namespace Supported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap> value, MarkAttributeDirty markDirty);
+} // namespace Supported
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAlarm
+
+namespace DishwasherMode {
+namespace Attributes {
+
+namespace StartUpMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpMode
+
+namespace OnMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OnMode
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DishwasherMode
+
+namespace AirQuality {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AirQuality
+
+namespace SmokeCoAlarm {
+namespace Attributes {
+
+namespace ExpressedState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum * value); // ExpressedStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ExpressedState
+
+namespace SmokeState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value); // AlarmStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace SmokeState
+
+namespace COState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value); // AlarmStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace COState
+
+namespace BatteryAlert {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value); // AlarmStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace BatteryAlert
+
+namespace DeviceMuted {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::MuteStateEnum * value); // MuteStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::MuteStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::MuteStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace DeviceMuted
+
+namespace TestInProgress {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace TestInProgress
+
+namespace HardwareFaultAlert {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace HardwareFaultAlert
+
+namespace EndOfServiceAlert {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum * value); // EndOfServiceEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace EndOfServiceAlert
+
+namespace InterconnectSmokeAlarm {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value); // AlarmStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace InterconnectSmokeAlarm
+
+namespace InterconnectCOAlarm {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum * value); // AlarmStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace InterconnectCOAlarm
+
+namespace ContaminationState {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum * value); // ContaminationStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ContaminationState
+
+namespace SmokeSensitivityLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::SmokeCoAlarm::SensitivityEnum * value); // SensitivityEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::SensitivityEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::SmokeCoAlarm::SensitivityEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace SmokeSensitivityLevel
+
+namespace ExpiryDate {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // epoch_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace ExpiryDate
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SmokeCoAlarm
+
+namespace DishwasherAlarm {
+namespace Attributes {
+
+namespace Mask {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Mask
+
+namespace Latch {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Latch
+
+namespace State {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace State
+
+namespace Supported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> * value); // AlarmBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Supported
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DishwasherAlarm
+
+namespace MicrowaveOvenMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MicrowaveOvenMode
+
+namespace MicrowaveOvenControl {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MicrowaveOvenControl
+
+namespace OperationalState {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OperationalState
+
+namespace RvcOperationalState {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcOperationalState
+
+namespace ScenesManagement {
+namespace Attributes {
+
+namespace LastConfiguredBy {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::NodeId> & value); // node_id
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::NodeId value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::NodeId value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::NodeId> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::NodeId> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LastConfiguredBy
+
+namespace SceneTableSize {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace SceneTableSize
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ScenesManagement
+
+namespace HepaFilterMonitoring {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace HepaFilterMonitoring
+
+namespace ActivatedCarbonFilterMonitoring {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ActivatedCarbonFilterMonitoring
+
+namespace BooleanStateConfiguration {
+namespace Attributes {
+
+namespace SupportedSensitivityLevels {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SupportedSensitivityLevels
+
+namespace DefaultSensitivityLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace DefaultSensitivityLevel
+
+namespace AlarmsActive {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value); // AlarmModeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace AlarmsActive
+
+namespace AlarmsSuppressed {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value); // AlarmModeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace AlarmsSuppressed
+
+namespace AlarmsEnabled {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value); // AlarmModeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace AlarmsEnabled
+
+namespace AlarmsSupported {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> * value); // AlarmModeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace AlarmsSupported
+
+namespace SensorFault {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap> * value); // SensorFaultBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace SensorFault
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BooleanStateConfiguration
+
+namespace ValveConfigurationAndControl {
+namespace Attributes {
+
+namespace OpenDuration {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // elapsed_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OpenDuration
+
+namespace DefaultOpenDuration {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // elapsed_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace DefaultOpenDuration
+
+namespace AutoCloseTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // epoch_us
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace AutoCloseTime
+
+namespace CurrentState {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value); // ValveStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentState
+
+namespace TargetState {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value); // ValveStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace TargetState
+
+namespace CurrentLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentLevel
+
+namespace TargetLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty);
+} // namespace TargetLevel
+
+namespace DefaultOpenLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::Percent * value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+} // namespace DefaultOpenLevel
+
+namespace ValveFault {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap> * value); // ValveFaultBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace ValveFault
+
+namespace LevelStep {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace LevelStep
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ValveConfigurationAndControl
+
+namespace ElectricalPowerMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ElectricalPowerMeasurement
+
+namespace ElectricalEnergyMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ElectricalEnergyMeasurement
+
+namespace WaterHeaterManagement {
+namespace Attributes {} // namespace Attributes
+} // namespace WaterHeaterManagement
+
+namespace DemandResponseLoadControl {
+namespace Attributes {
+
+namespace NumberOfLoadControlPrograms {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfLoadControlPrograms
+
+namespace NumberOfEventsPerProgram {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfEventsPerProgram
+
+namespace NumberOfTransitions {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfTransitions
+
+namespace DefaultRandomStart {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace DefaultRandomStart
+
+namespace DefaultRandomDuration {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace DefaultRandomDuration
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DemandResponseLoadControl
+
+namespace Messages {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Messages
+
+namespace DeviceEnergyManagement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DeviceEnergyManagement
+
+namespace EnergyEvse {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyEvse
+
+namespace EnergyPreference {
+namespace Attributes {
+
+namespace CurrentEnergyBalance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentEnergyBalance
+
+namespace CurrentLowPowerModeSensitivity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentLowPowerModeSensitivity
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyPreference
+
+namespace PowerTopology {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerTopology
+
+namespace EnergyEvseMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyEvseMode
+
+namespace WaterHeaterMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WaterHeaterMode
+
+namespace DeviceEnergyManagementMode {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DeviceEnergyManagementMode
+
+namespace DoorLock {
+namespace Attributes {
+
+namespace LockState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value); // DlLockState
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockState value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockState value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LockState
+
+namespace LockType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType * value); // DlLockType
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType value,
+ MarkAttributeDirty markDirty);
+} // namespace LockType
+
+namespace ActuatorEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace ActuatorEnabled
+
+namespace DoorState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> & value); // DoorStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DoorStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::DoorStateEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace DoorState
+
+namespace DoorOpenEvents {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace DoorOpenEvents
+
+namespace DoorClosedEvents {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace DoorClosedEvents
+
+namespace OpenPeriod {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace OpenPeriod
+
+namespace NumberOfTotalUsersSupported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfTotalUsersSupported
+
+namespace NumberOfPINUsersSupported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfPINUsersSupported
+
+namespace NumberOfRFIDUsersSupported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfRFIDUsersSupported
+
+namespace NumberOfWeekDaySchedulesSupportedPerUser {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfWeekDaySchedulesSupportedPerUser
+
+namespace NumberOfYearDaySchedulesSupportedPerUser {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfYearDaySchedulesSupportedPerUser
+
+namespace NumberOfHolidaySchedulesSupported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfHolidaySchedulesSupported
+
+namespace MaxPINCodeLength {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxPINCodeLength
+
+namespace MinPINCodeLength {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MinPINCodeLength
+
+namespace MaxRFIDCodeLength {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxRFIDCodeLength
+
+namespace MinRFIDCodeLength {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MinRFIDCodeLength
+
+namespace CredentialRulesSupport {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> * value); // DlCredentialRuleMask
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> value, MarkAttributeDirty markDirty);
+} // namespace CredentialRulesSupport
+
+namespace NumberOfCredentialsSupportedPerUser {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfCredentialsSupportedPerUser
+
+namespace Language {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace Language
+
+namespace LEDSettings {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace LEDSettings
+
+namespace AutoRelockTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace AutoRelockTime
+
+namespace SoundVolume {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SoundVolume
+
+namespace OperatingMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::DoorLock::OperatingModeEnum * value); // OperatingModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace OperatingMode
+
+namespace SupportedOperatingModes {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> * value); // DlSupportedOperatingModes
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> value,
+ MarkAttributeDirty markDirty);
+} // namespace SupportedOperatingModes
+
+namespace DefaultConfigurationRegister {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> * value); // DlDefaultConfigurationRegister
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> value,
+ MarkAttributeDirty markDirty);
+} // namespace DefaultConfigurationRegister
+
+namespace EnableLocalProgramming {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace EnableLocalProgramming
+
+namespace EnableOneTouchLocking {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace EnableOneTouchLocking
+
+namespace EnableInsideStatusLED {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace EnableInsideStatusLED
+
+namespace EnablePrivacyModeButton {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace EnablePrivacyModeButton
+
+namespace LocalProgrammingFeatures {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> * value); // DlLocalProgrammingFeatures
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> value,
+ MarkAttributeDirty markDirty);
+} // namespace LocalProgrammingFeatures
+
+namespace WrongCodeEntryLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace WrongCodeEntryLimit
+
+namespace UserCodeTemporaryDisableTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace UserCodeTemporaryDisableTime
+
+namespace SendPINOverTheAir {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace SendPINOverTheAir
+
+namespace RequirePINforRemoteOperation {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace RequirePINforRemoteOperation
+
+namespace ExpiringUserTimeout {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ExpiringUserTimeout
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DoorLock
+
+namespace WindowCovering {
+namespace Attributes {
+
+namespace Type {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::WindowCovering::Type * value); // Type
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::Type value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::Type value,
+ MarkAttributeDirty markDirty);
+} // namespace Type
+
+namespace PhysicalClosedLimitLift {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace PhysicalClosedLimitLift
+
+namespace PhysicalClosedLimitTilt {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace PhysicalClosedLimitTilt
+
+namespace CurrentPositionLift {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentPositionLift
+
+namespace CurrentPositionTilt {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentPositionTilt
+
+namespace NumberOfActuationsLift {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfActuationsLift
+
+namespace NumberOfActuationsTilt {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfActuationsTilt
+
+namespace ConfigStatus {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> * value); // ConfigStatus
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> value,
+ MarkAttributeDirty markDirty);
+} // namespace ConfigStatus
+
+namespace CurrentPositionLiftPercentage {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentPositionLiftPercentage
+
+namespace CurrentPositionTiltPercentage {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentPositionTiltPercentage
+
+namespace OperationalStatus {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> * value); // OperationalStatus
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> value, MarkAttributeDirty markDirty);
+} // namespace OperationalStatus
+
+namespace TargetPositionLiftPercent100ths {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value); // percent100ths
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty);
+} // namespace TargetPositionLiftPercent100ths
+
+namespace TargetPositionTiltPercent100ths {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value); // percent100ths
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty);
+} // namespace TargetPositionTiltPercent100ths
+
+namespace EndProductType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::WindowCovering::EndProductType * value); // EndProductType
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType value,
+ MarkAttributeDirty markDirty);
+} // namespace EndProductType
+
+namespace CurrentPositionLiftPercent100ths {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value); // percent100ths
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentPositionLiftPercent100ths
+
+namespace CurrentPositionTiltPercent100ths {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent100ths> & value); // percent100ths
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent100ths value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent100ths> & value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentPositionTiltPercent100ths
+
+namespace InstalledOpenLimitLift {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace InstalledOpenLimitLift
+
+namespace InstalledClosedLimitLift {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace InstalledClosedLimitLift
+
+namespace InstalledOpenLimitTilt {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace InstalledOpenLimitTilt
+
+namespace InstalledClosedLimitTilt {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace InstalledClosedLimitTilt
+
+namespace Mode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::Mode> * value); // Mode
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> value,
+ MarkAttributeDirty markDirty);
+} // namespace Mode
+
+namespace SafetyStatus {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> * value); // SafetyStatus
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> value,
+ MarkAttributeDirty markDirty);
+} // namespace SafetyStatus
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WindowCovering
+
+namespace ServiceArea {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ServiceArea
+
+namespace PumpConfigurationAndControl {
+namespace Attributes {
+
+namespace MaxPressure {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxPressure
+
+namespace MaxSpeed {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxSpeed
+
+namespace MaxFlow {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxFlow
+
+namespace MinConstPressure {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinConstPressure
+
+namespace MaxConstPressure {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxConstPressure
+
+namespace MinCompPressure {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinCompPressure
+
+namespace MaxCompPressure {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxCompPressure
+
+namespace MinConstSpeed {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinConstSpeed
+
+namespace MaxConstSpeed {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxConstSpeed
+
+namespace MinConstFlow {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinConstFlow
+
+namespace MaxConstFlow {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxConstFlow
+
+namespace MinConstTemp {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinConstTemp
+
+namespace MaxConstTemp {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxConstTemp
+
+namespace PumpStatus {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap> * value); // PumpStatusBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace PumpStatus
+
+namespace EffectiveOperationMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value); // OperationModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value, MarkAttributeDirty markDirty);
+} // namespace EffectiveOperationMode
+
+namespace EffectiveControlMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value); // ControlModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value, MarkAttributeDirty markDirty);
+} // namespace EffectiveControlMode
+
+namespace Capacity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Capacity
+
+namespace Speed {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Speed
+
+namespace LifetimeRunningHours {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LifetimeRunningHours
+
+namespace Power {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Power
+
+namespace LifetimeEnergyConsumed {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LifetimeEnergyConsumed
+
+namespace OperationMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value); // OperationModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value, MarkAttributeDirty markDirty);
+} // namespace OperationMode
+
+namespace ControlMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value); // ControlModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value, MarkAttributeDirty markDirty);
+} // namespace ControlMode
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PumpConfigurationAndControl
+
+namespace Thermostat {
+namespace Attributes {
+
+namespace LocalTemperature {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LocalTemperature
+
+namespace OutdoorTemperature {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OutdoorTemperature
+
+namespace Occupancy {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap> * value); // OccupancyBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Occupancy
+
+namespace AbsMinHeatSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace AbsMinHeatSetpointLimit
+
+namespace AbsMaxHeatSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace AbsMaxHeatSetpointLimit
+
+namespace AbsMinCoolSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace AbsMinCoolSetpointLimit
+
+namespace AbsMaxCoolSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace AbsMaxCoolSetpointLimit
+
+namespace PICoolingDemand {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace PICoolingDemand
+
+namespace PIHeatingDemand {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace PIHeatingDemand
+
+namespace HVACSystemTypeConfiguration {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap> * value); // HVACSystemTypeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap> value, MarkAttributeDirty markDirty);
+} // namespace HVACSystemTypeConfiguration
+
+namespace LocalTemperatureCalibration {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+} // namespace LocalTemperatureCalibration
+
+namespace OccupiedCoolingSetpoint {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace OccupiedCoolingSetpoint
+
+namespace OccupiedHeatingSetpoint {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace OccupiedHeatingSetpoint
+
+namespace UnoccupiedCoolingSetpoint {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace UnoccupiedCoolingSetpoint
+
+namespace UnoccupiedHeatingSetpoint {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace UnoccupiedHeatingSetpoint
+
+namespace MinHeatSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace MinHeatSetpointLimit
+
+namespace MaxHeatSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace MaxHeatSetpointLimit
+
+namespace MinCoolSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace MinCoolSetpointLimit
+
+namespace MaxCoolSetpointLimit {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace MaxCoolSetpointLimit
+
+namespace MinSetpointDeadBand {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+} // namespace MinSetpointDeadBand
+
+namespace RemoteSensing {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap> * value); // RemoteSensingBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap> value, MarkAttributeDirty markDirty);
+} // namespace RemoteSensing
+
+namespace ControlSequenceOfOperation {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum * value); // ControlSequenceOfOperationEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ControlSequenceOfOperation
+
+namespace SystemMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::SystemModeEnum * value); // SystemModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SystemModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SystemModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace SystemMode
+
+namespace ThermostatRunningMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatRunningModeEnum * value); // ThermostatRunningModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatRunningModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatRunningModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ThermostatRunningMode
+
+namespace StartOfWeek {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::StartOfWeekEnum * value); // StartOfWeekEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::StartOfWeekEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::StartOfWeekEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace StartOfWeek
+
+namespace NumberOfWeeklyTransitions {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfWeeklyTransitions
+
+namespace NumberOfDailyTransitions {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfDailyTransitions
+
+namespace TemperatureSetpointHold {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum * value); // TemperatureSetpointHoldEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TemperatureSetpointHold
+
+namespace TemperatureSetpointHoldDuration {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace TemperatureSetpointHoldDuration
+
+namespace ThermostatProgrammingOperationMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap> * value); // ProgrammingOperationModeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace ThermostatProgrammingOperationMode
+
+namespace ThermostatRunningState {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap> * value); // RelayStateBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace ThermostatRunningState
+
+namespace SetpointChangeSource {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::Thermostat::SetpointChangeSourceEnum * value); // SetpointChangeSourceEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SetpointChangeSourceEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::SetpointChangeSourceEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace SetpointChangeSource
+
+namespace SetpointChangeAmount {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SetpointChangeAmount
+
+namespace SetpointChangeSourceTimestamp {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // epoch_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace SetpointChangeSourceTimestamp
+
+namespace OccupiedSetback {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OccupiedSetback
+
+namespace OccupiedSetbackMin {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OccupiedSetbackMin
+
+namespace OccupiedSetbackMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace OccupiedSetbackMax
+
+namespace UnoccupiedSetback {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace UnoccupiedSetback
+
+namespace UnoccupiedSetbackMin {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace UnoccupiedSetbackMin
+
+namespace UnoccupiedSetbackMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace UnoccupiedSetbackMax
+
+namespace EmergencyHeatDelta {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace EmergencyHeatDelta
+
+namespace ACType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::Thermostat::ACTypeEnum * value); // ACTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ACType
+
+namespace ACCapacity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ACCapacity
+
+namespace ACRefrigerantType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum * value); // ACRefrigerantTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ACRefrigerantType
+
+namespace ACCompressorType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::ACCompressorTypeEnum * value); // ACCompressorTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCompressorTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCompressorTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ACCompressorType
+
+namespace ACErrorCode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap> * value); // ACErrorCodeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap> value, MarkAttributeDirty markDirty);
+} // namespace ACErrorCode
+
+namespace ACLouverPosition {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::ACLouverPositionEnum * value); // ACLouverPositionEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACLouverPositionEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACLouverPositionEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ACLouverPosition
+
+namespace ACCoilTemperature {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ACCoilTemperature
+
+namespace ACCapacityformat {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Thermostat::ACCapacityFormatEnum * value); // ACCapacityFormatEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCapacityFormatEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Thermostat::ACCapacityFormatEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ACCapacityformat
+
+namespace NumberOfPresets {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfPresets
+
+namespace NumberOfSchedules {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfSchedules
+
+namespace NumberOfScheduleTransitions {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace NumberOfScheduleTransitions
+
+namespace NumberOfScheduleTransitionPerDay {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NumberOfScheduleTransitionPerDay
+
+namespace ActivePresetHandle {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value); // octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ActivePresetHandle
+
+namespace ActiveScheduleHandle {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value); // octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ActiveScheduleHandle
+
+namespace SetpointHoldExpiryTimestamp {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // epoch_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SetpointHoldExpiryTimestamp
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Thermostat
+
+namespace FanControl {
+namespace Attributes {
+
+namespace FanMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeEnum * value); // FanModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace FanMode
+
+namespace FanModeSequence {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::FanControl::FanModeSequenceEnum * value); // FanModeSequenceEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace FanModeSequence
+
+namespace PercentSetting {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::Percent> & value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::Percent> & value,
+ MarkAttributeDirty markDirty);
+} // namespace PercentSetting
+
+namespace PercentCurrent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::Percent * value); // percent
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::Percent value, MarkAttributeDirty markDirty);
+} // namespace PercentCurrent
+
+namespace SpeedMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SpeedMax
+
+namespace SpeedSetting {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SpeedSetting
+
+namespace SpeedCurrent {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SpeedCurrent
+
+namespace RockSupport {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> * value); // RockBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace RockSupport
+
+namespace RockSetting {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> * value); // RockBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::RockBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace RockSetting
+
+namespace WindSupport {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> * value); // WindBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace WindSupport
+
+namespace WindSetting {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> * value); // WindBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::FanControl::WindBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace WindSetting
+
+namespace AirflowDirection {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::FanControl::AirflowDirectionEnum * value); // AirflowDirectionEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::AirflowDirectionEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::FanControl::AirflowDirectionEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace AirflowDirection
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FanControl
+
+namespace ThermostatUserInterfaceConfiguration {
+namespace Attributes {
+
+namespace TemperatureDisplayMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum * value); // TemperatureDisplayModeEnum
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TemperatureDisplayMode
+
+namespace KeypadLockout {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum * value); // KeypadLockoutEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace KeypadLockout
+
+namespace ScheduleProgrammingVisibility {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum *
+ value); // ScheduleProgrammingVisibilityEnum
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ScheduleProgrammingVisibility
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThermostatUserInterfaceConfiguration
+
+namespace ColorControl {
+namespace Attributes {
+
+namespace CurrentHue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentHue
+
+namespace CurrentSaturation {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentSaturation
+
+namespace RemainingTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace RemainingTime
+
+namespace CurrentX {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentX
+
+namespace CurrentY {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentY
+
+namespace DriftCompensation {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::ColorControl::DriftCompensationEnum * value); // DriftCompensationEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::DriftCompensationEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::DriftCompensationEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace DriftCompensation
+
+namespace CompensationText {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace CompensationText
+
+namespace ColorTemperatureMireds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorTemperatureMireds
+
+namespace ColorMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::ColorControl::ColorModeEnum * value); // ColorModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::ColorModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::ColorModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace ColorMode
+
+namespace Options {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap> * value); // OptionsBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Options
+
+namespace NumberOfPrimaries {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NumberOfPrimaries
+
+namespace Primary1X {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary1X
+
+namespace Primary1Y {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary1Y
+
+namespace Primary1Intensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Primary1Intensity
+
+namespace Primary2X {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary2X
+
+namespace Primary2Y {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary2Y
+
+namespace Primary2Intensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Primary2Intensity
+
+namespace Primary3X {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary3X
+
+namespace Primary3Y {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary3Y
+
+namespace Primary3Intensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Primary3Intensity
+
+namespace Primary4X {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary4X
+
+namespace Primary4Y {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary4Y
+
+namespace Primary4Intensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Primary4Intensity
+
+namespace Primary5X {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary5X
+
+namespace Primary5Y {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary5Y
+
+namespace Primary5Intensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Primary5Intensity
+
+namespace Primary6X {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary6X
+
+namespace Primary6Y {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Primary6Y
+
+namespace Primary6Intensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Primary6Intensity
+
+namespace WhitePointX {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace WhitePointX
+
+namespace WhitePointY {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace WhitePointY
+
+namespace ColorPointRX {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorPointRX
+
+namespace ColorPointRY {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorPointRY
+
+namespace ColorPointRIntensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ColorPointRIntensity
+
+namespace ColorPointGX {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorPointGX
+
+namespace ColorPointGY {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorPointGY
+
+namespace ColorPointGIntensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ColorPointGIntensity
+
+namespace ColorPointBX {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorPointBX
+
+namespace ColorPointBY {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorPointBY
+
+namespace ColorPointBIntensity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ColorPointBIntensity
+
+namespace EnhancedCurrentHue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace EnhancedCurrentHue
+
+namespace EnhancedColorMode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::ColorControl::EnhancedColorModeEnum * value); // EnhancedColorModeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::EnhancedColorModeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ColorControl::EnhancedColorModeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace EnhancedColorMode
+
+namespace ColorLoopActive {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace ColorLoopActive
+
+namespace ColorLoopDirection {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace ColorLoopDirection
+
+namespace ColorLoopTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorLoopTime
+
+namespace ColorLoopStartEnhancedHue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorLoopStartEnhancedHue
+
+namespace ColorLoopStoredEnhancedHue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorLoopStoredEnhancedHue
+
+namespace ColorCapabilities {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap> * value); // ColorCapabilitiesBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace ColorCapabilities
+
+namespace ColorTempPhysicalMinMireds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorTempPhysicalMinMireds
+
+namespace ColorTempPhysicalMaxMireds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ColorTempPhysicalMaxMireds
+
+namespace CoupleColorTempToLevelMinMireds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace CoupleColorTempToLevelMinMireds
+
+namespace StartUpColorTemperatureMireds {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartUpColorTemperatureMireds
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ColorControl
+
+namespace BallastConfiguration {
+namespace Attributes {
+
+namespace PhysicalMinLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace PhysicalMinLevel
+
+namespace PhysicalMaxLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace PhysicalMaxLevel
+
+namespace BallastStatus {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap> * value); // BallastStatusBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace BallastStatus
+
+namespace MinLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MinLevel
+
+namespace MaxLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxLevel
+
+namespace IntrinsicBallastFactor {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace IntrinsicBallastFactor
+
+namespace BallastFactorAdjustment {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace BallastFactorAdjustment
+
+namespace LampQuantity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace LampQuantity
+
+namespace LampType {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace LampType
+
+namespace LampManufacturer {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace LampManufacturer
+
+namespace LampRatedHours {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LampRatedHours
+
+namespace LampBurnHours {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LampBurnHours
+
+namespace LampAlarmMode {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap> * value); // LampAlarmModeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace LampAlarmMode
+
+namespace LampBurnHoursTripPoint {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LampBurnHoursTripPoint
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BallastConfiguration
+
+namespace IlluminanceMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Tolerance
+
+namespace LightSensorType {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> & value); // LightSensorTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace LightSensorType
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace IlluminanceMeasurement
+
+namespace TemperatureMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // temperature
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Tolerance
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TemperatureMeasurement
+
+namespace PressureMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Tolerance
+
+namespace ScaledValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace ScaledValue
+
+namespace MinScaledValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinScaledValue
+
+namespace MaxScaledValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxScaledValue
+
+namespace ScaledTolerance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ScaledTolerance
+
+namespace Scale {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+} // namespace Scale
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PressureMeasurement
+
+namespace FlowMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Tolerance
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FlowMeasurement
+
+namespace RelativeHumidityMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Tolerance
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RelativeHumidityMeasurement
+
+namespace OccupancySensing {
+namespace Attributes {
+
+namespace Occupancy {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap> * value); // OccupancyBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap> value, MarkAttributeDirty markDirty);
+} // namespace Occupancy
+
+namespace OccupancySensorType {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum * value); // OccupancySensorTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace OccupancySensorType
+
+namespace OccupancySensorTypeBitmap {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap> * value); // OccupancySensorTypeBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace OccupancySensorTypeBitmap
+
+namespace PIRUnoccupiedToOccupiedDelay {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace PIRUnoccupiedToOccupiedDelay
+
+namespace PIRUnoccupiedToOccupiedThreshold {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace PIRUnoccupiedToOccupiedThreshold
+
+namespace UltrasonicUnoccupiedToOccupiedDelay {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace UltrasonicUnoccupiedToOccupiedDelay
+
+namespace UltrasonicUnoccupiedToOccupiedThreshold {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace UltrasonicUnoccupiedToOccupiedThreshold
+
+namespace PhysicalContactUnoccupiedToOccupiedDelay {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace PhysicalContactUnoccupiedToOccupiedDelay
+
+namespace PhysicalContactUnoccupiedToOccupiedThreshold {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace PhysicalContactUnoccupiedToOccupiedThreshold
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OccupancySensing
+
+namespace CarbonMonoxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CarbonMonoxideConcentrationMeasurement
+
+namespace CarbonDioxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CarbonDioxideConcentrationMeasurement
+
+namespace NitrogenDioxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace NitrogenDioxideConcentrationMeasurement
+
+namespace OzoneConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OzoneConcentrationMeasurement
+
+namespace Pm25ConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm25ConcentrationMeasurement
+
+namespace FormaldehydeConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FormaldehydeConcentrationMeasurement
+
+namespace Pm1ConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm1ConcentrationMeasurement
+
+namespace Pm10ConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm10ConcentrationMeasurement
+
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+
+namespace RadonConcentrationMeasurement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RadonConcentrationMeasurement
+
+namespace WiFiNetworkManagement {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WiFiNetworkManagement
+
+namespace ThreadBorderRouterManagement {
+namespace Attributes {
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadBorderRouterManagement
+
+namespace ThreadNetworkDirectory {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadNetworkDirectory
+
+namespace WakeOnLan {
+namespace Attributes {
+
+namespace MACAddress {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace MACAddress
+
+namespace LinkLocalAddress {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableByteSpan & value); // octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+} // namespace LinkLocalAddress
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WakeOnLan
+
+namespace Channel {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Channel
+
+namespace TargetNavigator {
+namespace Attributes {
+
+namespace CurrentTarget {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentTarget
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TargetNavigator
+
+namespace MediaPlayback {
+namespace Attributes {
+
+namespace CurrentState {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::MediaPlayback::PlaybackStateEnum * value); // PlaybackStateEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace CurrentState
+
+namespace StartTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // epoch_us
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace StartTime
+
+namespace Duration {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int64u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace Duration
+
+namespace PlaybackSpeed {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, float * value); // single
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value, MarkAttributeDirty markDirty);
+} // namespace PlaybackSpeed
+
+namespace SeekRangeEnd {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int64u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SeekRangeEnd
+
+namespace SeekRangeStart {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int64u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace SeekRangeStart
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MediaPlayback
+
+namespace MediaInput {
+namespace Attributes {
+
+namespace CurrentInput {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentInput
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MediaInput
+
+namespace LowPower {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LowPower
+
+namespace KeypadInput {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace KeypadInput
+
+namespace ContentLauncher {
+namespace Attributes {
+
+namespace SupportedStreamingProtocols {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap> * value); // SupportedProtocolsBitmap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace SupportedStreamingProtocols
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentLauncher
+
+namespace AudioOutput {
+namespace Attributes {
+
+namespace CurrentOutput {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentOutput
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AudioOutput
+
+namespace ApplicationLauncher {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ApplicationLauncher
+
+namespace ApplicationBasic {
+namespace Attributes {
+
+namespace VendorName {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace VendorName
+
+namespace VendorID {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::VendorId * value); // vendor_id
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value, MarkAttributeDirty markDirty);
+} // namespace VendorID
+
+namespace ApplicationName {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // long_char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ApplicationName
+
+namespace ProductID {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ProductID
+
+namespace Status {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum * value); // ApplicationStatusEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace Status
+
+namespace ApplicationVersion {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ApplicationVersion
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ApplicationBasic
+
+namespace AccountLogin {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AccountLogin
+
+namespace ContentControl {
+namespace Attributes {
+
+namespace Enabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace Enabled
+
+namespace OnDemandRatingThreshold {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace OnDemandRatingThreshold
+
+namespace ScheduledContentRatingThreshold {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace ScheduledContentRatingThreshold
+
+namespace ScreenDailyTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // elapsed_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace ScreenDailyTime
+
+namespace RemainingScreenTime {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // elapsed_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace RemainingScreenTime
+
+namespace BlockUnrated {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace BlockUnrated
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentControl
+
+namespace ContentAppObserver {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentAppObserver
+
+namespace ZoneManagement {
+namespace Attributes {
+
+namespace Sensitivity {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace Sensitivity
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ZoneManagement
+
+namespace CameraAvStreamManagement {
+namespace Attributes {
+
+namespace MaxConcurrentVideoEncoders {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxConcurrentVideoEncoders
+
+namespace MaxEncodedPixelRate {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace MaxEncodedPixelRate
+
+namespace NightVisionCapable {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace NightVisionCapable
+
+namespace MaxContentBufferSize {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace MaxContentBufferSize
+
+namespace TwoWayTalkSupport {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum * value); // TwoWayTalkSupportTypeEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace TwoWayTalkSupport
+
+namespace MaxNetworkBandwidth {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace MaxNetworkBandwidth
+
+namespace CurrentFrameRate {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace CurrentFrameRate
+
+namespace HDRModeEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace HDRModeEnabled
+
+namespace SoftRecordingPrivacyModeEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace SoftRecordingPrivacyModeEnabled
+
+namespace SoftLivestreamPrivacyModeEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace SoftLivestreamPrivacyModeEnabled
+
+namespace HardPrivacyModeOn {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace HardPrivacyModeOn
+
+namespace NightVision {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum * value); // TriStateAutoEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace NightVision
+
+namespace NightVisionIllum {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum * value); // TriStateAutoEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace NightVisionIllum
+
+namespace SpeakerMuted {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace SpeakerMuted
+
+namespace SpeakerVolumeLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SpeakerVolumeLevel
+
+namespace SpeakerMaxLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SpeakerMaxLevel
+
+namespace SpeakerMinLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace SpeakerMinLevel
+
+namespace MicrophoneMuted {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace MicrophoneMuted
+
+namespace MicrophoneVolumeLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MicrophoneVolumeLevel
+
+namespace MicrophoneMaxLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MicrophoneMaxLevel
+
+namespace MicrophoneMinLevel {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MicrophoneMinLevel
+
+namespace MicrophoneAGCEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace MicrophoneAGCEnabled
+
+namespace ImageRotation {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ImageRotation
+
+namespace ImageFlipHorizontal {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace ImageFlipHorizontal
+
+namespace ImageFlipVertical {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace ImageFlipVertical
+
+namespace LocalVideoRecordingEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace LocalVideoRecordingEnabled
+
+namespace LocalSnapshotRecordingEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace LocalSnapshotRecordingEnabled
+
+namespace StatusLightEnabled {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace StatusLightEnabled
+
+namespace StatusLightBrightness {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Globals::ThreeLevelAutoEnum * value); // ThreeLevelAutoEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::ThreeLevelAutoEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::ThreeLevelAutoEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace StatusLightBrightness
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CameraAvStreamManagement
+
+namespace CameraAvSettingsUserLevelManagement {
+namespace Attributes {
+
+namespace MaxPresets {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MaxPresets
+
+namespace ZoomMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace ZoomMax
+
+namespace TiltMin {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace TiltMin
+
+namespace TiltMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace TiltMax
+
+namespace PanMin {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace PanMin
+
+namespace PanMax {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace PanMax
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CameraAvSettingsUserLevelManagement
+
+namespace WebRTCTransportProvider {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WebRTCTransportProvider
+
+namespace WebRTCTransportRequestor {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WebRTCTransportRequestor
+
+namespace Chime {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Chime
+
+namespace EcosystemInformation {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EcosystemInformation
+
+namespace CommissionerControl {
+namespace Attributes {
+
+namespace SupportedDeviceCategories {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap> *
+ value); // SupportedDeviceCategoryBitmap
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap> value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap> value,
+ MarkAttributeDirty markDirty);
+} // namespace SupportedDeviceCategories
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CommissionerControl
+
+namespace UnitTesting {
+namespace Attributes {
+
+namespace Boolean {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace Boolean
+
+namespace Bitmap8 {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> * value); // Bitmap8MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Bitmap8
+
+namespace Bitmap16 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> * value); // Bitmap16MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Bitmap16
+
+namespace Bitmap32 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> * value); // Bitmap32MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Bitmap32
+
+namespace Bitmap64 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> * value); // Bitmap64MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value,
+ MarkAttributeDirty markDirty);
+} // namespace Bitmap64
+
+namespace Int8u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace Int8u
+
+namespace Int16u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Int16u
+
+namespace Int24u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace Int24u
+
+namespace Int32u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace Int32u
+
+namespace Int40u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value); // int40u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+} // namespace Int40u
+
+namespace Int48u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value); // int48u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+} // namespace Int48u
+
+namespace Int56u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value); // int56u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+} // namespace Int56u
+
+namespace Int64u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value); // int64u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+} // namespace Int64u
+
+namespace Int8s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+} // namespace Int8s
+
+namespace Int16s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace Int16s
+
+namespace Int24s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int32_t * value); // int24s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty);
+} // namespace Int24s
+
+namespace Int32s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int32_t * value); // int32s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty);
+} // namespace Int32s
+
+namespace Int40s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value); // int40s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+} // namespace Int40s
+
+namespace Int48s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value); // int48s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+} // namespace Int48s
+
+namespace Int56s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value); // int56s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+} // namespace Int56s
+
+namespace Int64s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int64_t * value); // int64s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+} // namespace Int64s
+
+namespace Enum8 {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // enum8
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace Enum8
+
+namespace Enum16 {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // enum16
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace Enum16
+
+namespace FloatSingle {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, float * value); // single
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value, MarkAttributeDirty markDirty);
+} // namespace FloatSingle
+
+namespace FloatDouble {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, double * value); // double
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value, MarkAttributeDirty markDirty);
+} // namespace FloatDouble
+
+namespace OctetString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableByteSpan & value); // octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+} // namespace OctetString
+
+namespace LongOctetString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableByteSpan & value); // long_octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+} // namespace LongOctetString
+
+namespace CharString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace CharString
+
+namespace LongCharString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::MutableCharSpan & value); // long_char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+} // namespace LongCharString
+
+namespace EpochUs {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint64_t * value); // epoch_us
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+} // namespace EpochUs
+
+namespace EpochS {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // epoch_s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace EpochS
+
+namespace VendorId {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::VendorId * value); // vendor_id
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::VendorId value, MarkAttributeDirty markDirty);
+} // namespace VendorId
+
+namespace EnumAttr {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum * value); // SimpleEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace EnumAttr
+
+namespace RangeRestrictedInt8u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace RangeRestrictedInt8u
+
+namespace RangeRestrictedInt8s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int8_t * value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+} // namespace RangeRestrictedInt8s
+
+namespace RangeRestrictedInt16u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace RangeRestrictedInt16u
+
+namespace RangeRestrictedInt16s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, int16_t * value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+} // namespace RangeRestrictedInt16s
+
+namespace TimedWriteBoolean {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace TimedWriteBoolean
+
+namespace GlobalEnum {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ chip::app::Clusters::Globals::TestGlobalEnum * value); // TestGlobalEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value,
+ MarkAttributeDirty markDirty);
+} // namespace GlobalEnum
+
+namespace Unsupported {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace Unsupported
+
+namespace ReadFailureCode {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace ReadFailureCode
+
+namespace FailureInt32U {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FailureInt32U
+
+namespace NullableBoolean {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<bool> & value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<bool> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<bool> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableBoolean
+
+namespace NullableBitmap8 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> & value); // Bitmap8MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap> value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableBitmap8
+
+namespace NullableBitmap16 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> & value); // Bitmap16MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap> value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableBitmap16
+
+namespace NullableBitmap32 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> & value); // Bitmap32MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap> value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableBitmap32
+
+namespace NullableBitmap64 {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint,
+ DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> & value); // Bitmap64MaskMap
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap> value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> & value);
+Protocols::InteractionModel::Status
+Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableBitmap64
+
+namespace NullableInt8u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt8u
+
+namespace NullableInt16u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt16u
+
+namespace NullableInt24u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int24u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt24u
+
+namespace NullableInt32u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint32_t> & value); // int32u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt32u
+
+namespace NullableInt40u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int40u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt40u
+
+namespace NullableInt48u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int48u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt48u
+
+namespace NullableInt56u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int56u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt56u
+
+namespace NullableInt64u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint64_t> & value); // int64u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt64u
+
+namespace NullableInt8s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int8_t> & value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt8s
+
+namespace NullableInt16s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt16s
+
+namespace NullableInt24s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int32_t> & value); // int24s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt24s
+
+namespace NullableInt32s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int32_t> & value); // int32s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int32_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int32_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt32s
+
+namespace NullableInt40s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value); // int40s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt40s
+
+namespace NullableInt48s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value); // int48s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt48s
+
+namespace NullableInt56s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value); // int56s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt56s
+
+namespace NullableInt64s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int64_t> & value); // int64s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int64_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int64_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableInt64s
+
+namespace NullableEnum8 {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // enum8
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableEnum8
+
+namespace NullableEnum16 {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // enum16
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableEnum16
+
+namespace NullableFloatSingle {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<float> & value); // single
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, float value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<float> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<float> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableFloatSingle
+
+namespace NullableFloatDouble {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<double> & value); // double
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, double value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<double> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<double> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableFloatDouble
+
+namespace NullableOctetString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableByteSpan> & value); // octet_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::ByteSpan value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::ByteSpan> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableOctetString
+
+namespace NullableCharString {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<chip::MutableCharSpan> & value); // char_string
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::CharSpan value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::CharSpan> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<chip::CharSpan> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableCharString
+
+namespace NullableEnumAttr {
+Protocols::InteractionModel::Status Get(EndpointId endpoint,
+ DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> & value); // SimpleEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableEnumAttr
+
+namespace NullableRangeRestrictedInt8u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint8_t> & value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableRangeRestrictedInt8u
+
+namespace NullableRangeRestrictedInt8s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int8_t> & value); // int8s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int8_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int8_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableRangeRestrictedInt8s
+
+namespace NullableRangeRestrictedInt16u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<uint16_t> & value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<uint16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableRangeRestrictedInt16u
+
+namespace NullableRangeRestrictedInt16s {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, DataModel::Nullable<int16_t> & value); // int16s
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, int16_t value, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, const chip::app::DataModel::Nullable<int16_t> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableRangeRestrictedInt16s
+
+namespace WriteOnlyInt8u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace WriteOnlyInt8u
+
+namespace NullableGlobalEnum {
+Protocols::InteractionModel::Status
+Get(EndpointId endpoint, DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> & value); // TestGlobalEnum
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, chip::app::Clusters::Globals::TestGlobalEnum value,
+ MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint);
+Protocols::InteractionModel::Status SetNull(EndpointId endpoint, MarkAttributeDirty markDirty);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> & value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint,
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> & value,
+ MarkAttributeDirty markDirty);
+} // namespace NullableGlobalEnum
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+namespace MeiInt8u {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty);
+} // namespace MeiInt8u
+
+} // namespace Attributes
+} // namespace UnitTesting
+
+namespace FaultInjection {
+namespace Attributes {
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FaultInjection
+
+namespace SampleManufacturerSpecific {
+namespace Attributes {
+
+namespace FlipFlop {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace FlipFlop
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SampleManufacturerSpecific
+
+namespace SampleExternalManufacturerSpecific {
+namespace Attributes {
+
+namespace FlipFlop {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty);
+} // namespace FlipFlop
+
+namespace FeatureMap {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, MarkAttributeDirty markDirty);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value); // int16u
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value);
+Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/callback.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/callback.h
new file mode 100644
index 00000000000000..372227165c44b0
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/callback.h
@@ -0,0 +1,7235 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+// Prevent multiple inclusion
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/util/af-types.h>
+#include <app/util/basic-types.h>
+
+#include <app/CommandHandler.h>
+#include <app/CommandSender.h>
+#include <app/ConcreteAttributePath.h>
+#include <app/ConcreteCommandPath.h>
+#include <lib/support/Span.h>
+#include <protocols/interaction_model/Constants.h>
+
+// Cluster Init Functions
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIdentifyClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGroupsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOnOffClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLevelControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPulseWidthModulationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDescriptorClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBindingClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAccessControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfActionsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBasicInformationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOtaSoftwareUpdateProviderClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOtaSoftwareUpdateRequestorClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLocalizationConfigurationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimeFormatLocalizationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUnitLocalizationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerSourceConfigurationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerSourceClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGeneralCommissioningClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfNetworkCommissioningClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDiagnosticLogsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGeneralDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSoftwareDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWiFiNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEthernetNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimeSynchronizationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBridgedDeviceBasicInformationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSwitchClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAdministratorCommissioningClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOperationalCredentialsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGroupKeyManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFixedLabelClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUserLabelClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyConfigurationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyDiscoveryClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyValidClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBooleanStateClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIcdManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimerClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOvenCavityOperationalStateClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOvenModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryDryerControlsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfModeSelectClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryWasherModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAndTemperatureControlledCabinetModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryWasherControlsClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcRunModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcCleanModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTemperatureControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAlarmClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDishwasherModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAirQualityClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSmokeCoAlarmClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDishwasherAlarmClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMicrowaveOvenModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMicrowaveOvenControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOperationalStateClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcOperationalStateClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfScenesManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfHepaFilterMonitoringClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfActivatedCarbonFilterMonitoringClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBooleanStateConfigurationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfValveConfigurationAndControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfElectricalPowerMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfElectricalEnergyMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWaterHeaterManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDemandResponseLoadControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMessagesClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDeviceEnergyManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyEvseClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyPreferenceClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerTopologyClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyEvseModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWaterHeaterModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDeviceEnergyManagementModeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDoorLockClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWindowCoveringClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfServiceAreaClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPumpConfigurationAndControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThermostatClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFanControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThermostatUserInterfaceConfigurationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfColorControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBallastConfigurationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIlluminanceMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTemperatureMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPressureMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFlowMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRelativeHumidityMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOccupancySensingClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCarbonMonoxideConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCarbonDioxideConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfNitrogenDioxideConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOzoneConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm25ConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFormaldehydeConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm1ConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm10ConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTotalVolatileOrganicCompoundsConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRadonConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWiFiNetworkManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadBorderRouterManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadNetworkDirectoryClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWakeOnLanClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfChannelClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTargetNavigatorClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMediaPlaybackClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMediaInputClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLowPowerClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfKeypadInputClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentLauncherClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAudioOutputClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfApplicationLauncherClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfApplicationBasicClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAccountLoginClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentAppObserverClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfZoneManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCameraAvStreamManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCameraAvSettingsUserLevelManagementClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWebRTCTransportProviderClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWebRTCTransportRequestorClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfChimeClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEcosystemInformationClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCommissionerControlClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUnitTestingClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFaultInjectionClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSampleManufacturerSpecificClusterInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSampleExternalManufacturerSpecificClusterInitCallback(chip::EndpointId endpoint);
+
+// Cluster Server/Client Init Functions
+
+//
+// Identify Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIdentifyClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterIdentifyClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIdentifyClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterIdentifyClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterIdentifyClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfIdentifyClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Groups Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGroupsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterGroupsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGroupsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterGroupsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterGroupsClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfGroupsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// On/Off Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOnOffClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOnOffClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOnOffClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOnOffClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterOnOffClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOnOffClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Level Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLevelControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterLevelControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLevelControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterLevelControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterLevelControlClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfLevelControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Pulse Width Modulation Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPulseWidthModulationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPulseWidthModulationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPulseWidthModulationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPulseWidthModulationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPulseWidthModulationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPulseWidthModulationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Descriptor Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDescriptorClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDescriptorClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDescriptorClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDescriptorClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterDescriptorClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDescriptorClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Binding Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBindingClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterBindingClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBindingClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterBindingClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterBindingClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfBindingClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Access Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAccessControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterAccessControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAccessControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterAccessControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterAccessControlClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfAccessControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Actions Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfActionsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterActionsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfActionsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterActionsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterActionsClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfActionsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Basic Information Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBasicInformationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterBasicInformationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBasicInformationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterBasicInformationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterBasicInformationClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfBasicInformationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// OTA Software Update Provider Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOtaSoftwareUpdateProviderClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOtaSoftwareUpdateProviderClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOtaSoftwareUpdateProviderClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOtaSoftwareUpdateProviderClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterOtaSoftwareUpdateProviderClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOtaSoftwareUpdateProviderClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// OTA Software Update Requestor Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOtaSoftwareUpdateRequestorClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOtaSoftwareUpdateRequestorClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOtaSoftwareUpdateRequestorClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOtaSoftwareUpdateRequestorClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterOtaSoftwareUpdateRequestorClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOtaSoftwareUpdateRequestorClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Localization Configuration Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLocalizationConfigurationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterLocalizationConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLocalizationConfigurationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterLocalizationConfigurationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterLocalizationConfigurationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfLocalizationConfigurationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Time Format Localization Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimeFormatLocalizationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTimeFormatLocalizationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimeFormatLocalizationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTimeFormatLocalizationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterTimeFormatLocalizationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTimeFormatLocalizationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Unit Localization Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUnitLocalizationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterUnitLocalizationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUnitLocalizationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterUnitLocalizationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterUnitLocalizationClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfUnitLocalizationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Power Source Configuration Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerSourceConfigurationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPowerSourceConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerSourceConfigurationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPowerSourceConfigurationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPowerSourceConfigurationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPowerSourceConfigurationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Power Source Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerSourceClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPowerSourceClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerSourceClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPowerSourceClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterPowerSourceClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPowerSourceClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// General Commissioning Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGeneralCommissioningClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterGeneralCommissioningClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGeneralCommissioningClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterGeneralCommissioningClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterGeneralCommissioningClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfGeneralCommissioningClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Network Commissioning Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfNetworkCommissioningClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterNetworkCommissioningClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfNetworkCommissioningClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterNetworkCommissioningClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterNetworkCommissioningClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfNetworkCommissioningClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Diagnostic Logs Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDiagnosticLogsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDiagnosticLogsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDiagnosticLogsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDiagnosticLogsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterDiagnosticLogsClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDiagnosticLogsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// General Diagnostics Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGeneralDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterGeneralDiagnosticsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGeneralDiagnosticsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterGeneralDiagnosticsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterGeneralDiagnosticsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfGeneralDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Software Diagnostics Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSoftwareDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterSoftwareDiagnosticsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSoftwareDiagnosticsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterSoftwareDiagnosticsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterSoftwareDiagnosticsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfSoftwareDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Thread Network Diagnostics Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterThreadNetworkDiagnosticsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadNetworkDiagnosticsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterThreadNetworkDiagnosticsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterThreadNetworkDiagnosticsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfThreadNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Wi-Fi Network Diagnostics Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWiFiNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWiFiNetworkDiagnosticsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWiFiNetworkDiagnosticsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWiFiNetworkDiagnosticsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterWiFiNetworkDiagnosticsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWiFiNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Ethernet Network Diagnostics Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEthernetNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterEthernetNetworkDiagnosticsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEthernetNetworkDiagnosticsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterEthernetNetworkDiagnosticsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterEthernetNetworkDiagnosticsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfEthernetNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Time Synchronization Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimeSynchronizationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTimeSynchronizationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimeSynchronizationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTimeSynchronizationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterTimeSynchronizationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTimeSynchronizationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Bridged Device Basic Information Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBridgedDeviceBasicInformationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterBridgedDeviceBasicInformationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBridgedDeviceBasicInformationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterBridgedDeviceBasicInformationClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterBridgedDeviceBasicInformationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfBridgedDeviceBasicInformationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Switch Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSwitchClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterSwitchClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSwitchClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterSwitchClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterSwitchClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfSwitchClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Administrator Commissioning Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAdministratorCommissioningClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterAdministratorCommissioningClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAdministratorCommissioningClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterAdministratorCommissioningClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterAdministratorCommissioningClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfAdministratorCommissioningClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Operational Credentials Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOperationalCredentialsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOperationalCredentialsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOperationalCredentialsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOperationalCredentialsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterOperationalCredentialsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOperationalCredentialsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Group Key Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGroupKeyManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterGroupKeyManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfGroupKeyManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterGroupKeyManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterGroupKeyManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfGroupKeyManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Fixed Label Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFixedLabelClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterFixedLabelClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFixedLabelClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterFixedLabelClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterFixedLabelClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfFixedLabelClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// User Label Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUserLabelClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterUserLabelClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUserLabelClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterUserLabelClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterUserLabelClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfUserLabelClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Proxy Configuration Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyConfigurationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterProxyConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyConfigurationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterProxyConfigurationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterProxyConfigurationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfProxyConfigurationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Proxy Discovery Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyDiscoveryClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterProxyDiscoveryClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyDiscoveryClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterProxyDiscoveryClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterProxyDiscoveryClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfProxyDiscoveryClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Proxy Valid Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyValidClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterProxyValidClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfProxyValidClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterProxyValidClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterProxyValidClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfProxyValidClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Boolean State Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBooleanStateClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterBooleanStateClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBooleanStateClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterBooleanStateClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterBooleanStateClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfBooleanStateClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// ICD Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIcdManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterIcdManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIcdManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterIcdManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterIcdManagementClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfIcdManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Timer Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimerClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTimerClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTimerClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTimerClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterTimerClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTimerClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Oven Cavity Operational State Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOvenCavityOperationalStateClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOvenCavityOperationalStateClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOvenCavityOperationalStateClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOvenCavityOperationalStateClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterOvenCavityOperationalStateClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOvenCavityOperationalStateClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Oven Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOvenModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOvenModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOvenModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOvenModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterOvenModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOvenModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Laundry Dryer Controls Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryDryerControlsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterLaundryDryerControlsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryDryerControlsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterLaundryDryerControlsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterLaundryDryerControlsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfLaundryDryerControlsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Mode Select Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfModeSelectClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterModeSelectClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfModeSelectClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterModeSelectClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterModeSelectClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfModeSelectClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Laundry Washer Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryWasherModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterLaundryWasherModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryWasherModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterLaundryWasherModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterLaundryWasherModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfLaundryWasherModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Refrigerator And Temperature Controlled Cabinet Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAndTemperatureControlledCabinetModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRefrigeratorAndTemperatureControlledCabinetModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAndTemperatureControlledCabinetModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRefrigeratorAndTemperatureControlledCabinetModeClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterRefrigeratorAndTemperatureControlledCabinetModeClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRefrigeratorAndTemperatureControlledCabinetModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Laundry Washer Controls Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryWasherControlsClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterLaundryWasherControlsClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLaundryWasherControlsClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterLaundryWasherControlsClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterLaundryWasherControlsClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfLaundryWasherControlsClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// RVC Run Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcRunModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRvcRunModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcRunModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRvcRunModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterRvcRunModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRvcRunModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// RVC Clean Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcCleanModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRvcCleanModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcCleanModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRvcCleanModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterRvcCleanModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRvcCleanModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Temperature Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTemperatureControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTemperatureControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTemperatureControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTemperatureControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterTemperatureControlClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTemperatureControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Refrigerator Alarm Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAlarmClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRefrigeratorAlarmClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAlarmClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRefrigeratorAlarmClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterRefrigeratorAlarmClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRefrigeratorAlarmClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Dishwasher Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDishwasherModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDishwasherModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDishwasherModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDishwasherModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterDishwasherModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDishwasherModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Air Quality Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAirQualityClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterAirQualityClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAirQualityClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterAirQualityClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterAirQualityClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfAirQualityClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Smoke CO Alarm Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSmokeCoAlarmClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterSmokeCoAlarmClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSmokeCoAlarmClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterSmokeCoAlarmClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterSmokeCoAlarmClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfSmokeCoAlarmClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Dishwasher Alarm Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDishwasherAlarmClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDishwasherAlarmClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDishwasherAlarmClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDishwasherAlarmClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterDishwasherAlarmClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDishwasherAlarmClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Microwave Oven Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMicrowaveOvenModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterMicrowaveOvenModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMicrowaveOvenModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterMicrowaveOvenModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterMicrowaveOvenModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfMicrowaveOvenModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Microwave Oven Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMicrowaveOvenControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterMicrowaveOvenControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMicrowaveOvenControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterMicrowaveOvenControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterMicrowaveOvenControlClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfMicrowaveOvenControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Operational State Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOperationalStateClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOperationalStateClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOperationalStateClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOperationalStateClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterOperationalStateClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOperationalStateClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// RVC Operational State Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcOperationalStateClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRvcOperationalStateClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRvcOperationalStateClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRvcOperationalStateClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterRvcOperationalStateClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRvcOperationalStateClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Scenes Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfScenesManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterScenesManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfScenesManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterScenesManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterScenesManagementClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfScenesManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// HEPA Filter Monitoring Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfHepaFilterMonitoringClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterHepaFilterMonitoringClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfHepaFilterMonitoringClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterHepaFilterMonitoringClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterHepaFilterMonitoringClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfHepaFilterMonitoringClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Activated Carbon Filter Monitoring Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfActivatedCarbonFilterMonitoringClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterActivatedCarbonFilterMonitoringClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfActivatedCarbonFilterMonitoringClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterActivatedCarbonFilterMonitoringClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterActivatedCarbonFilterMonitoringClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfActivatedCarbonFilterMonitoringClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Boolean State Configuration Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBooleanStateConfigurationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterBooleanStateConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBooleanStateConfigurationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterBooleanStateConfigurationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterBooleanStateConfigurationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfBooleanStateConfigurationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Valve Configuration and Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfValveConfigurationAndControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterValveConfigurationAndControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfValveConfigurationAndControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterValveConfigurationAndControlClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterValveConfigurationAndControlClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfValveConfigurationAndControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Electrical Power Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfElectricalPowerMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterElectricalPowerMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfElectricalPowerMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterElectricalPowerMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterElectricalPowerMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfElectricalPowerMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Electrical Energy Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfElectricalEnergyMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterElectricalEnergyMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfElectricalEnergyMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterElectricalEnergyMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterElectricalEnergyMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfElectricalEnergyMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Water Heater Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWaterHeaterManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWaterHeaterManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWaterHeaterManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWaterHeaterManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterWaterHeaterManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWaterHeaterManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Demand Response Load Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDemandResponseLoadControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDemandResponseLoadControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDemandResponseLoadControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDemandResponseLoadControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterDemandResponseLoadControlClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDemandResponseLoadControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Messages Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMessagesClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterMessagesClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMessagesClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterMessagesClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterMessagesClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfMessagesClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Device Energy Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDeviceEnergyManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDeviceEnergyManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDeviceEnergyManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDeviceEnergyManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterDeviceEnergyManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDeviceEnergyManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Energy EVSE Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyEvseClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterEnergyEvseClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyEvseClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterEnergyEvseClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterEnergyEvseClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfEnergyEvseClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Energy Preference Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyPreferenceClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterEnergyPreferenceClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyPreferenceClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterEnergyPreferenceClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterEnergyPreferenceClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfEnergyPreferenceClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Power Topology Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerTopologyClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPowerTopologyClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPowerTopologyClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPowerTopologyClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterPowerTopologyClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPowerTopologyClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Energy EVSE Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyEvseModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterEnergyEvseModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEnergyEvseModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterEnergyEvseModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterEnergyEvseModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfEnergyEvseModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Water Heater Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWaterHeaterModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWaterHeaterModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWaterHeaterModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWaterHeaterModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterWaterHeaterModeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWaterHeaterModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Device Energy Management Mode Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDeviceEnergyManagementModeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDeviceEnergyManagementModeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDeviceEnergyManagementModeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDeviceEnergyManagementModeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterDeviceEnergyManagementModeClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDeviceEnergyManagementModeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Door Lock Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDoorLockClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterDoorLockClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfDoorLockClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterDoorLockClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterDoorLockClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfDoorLockClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Window Covering Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWindowCoveringClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWindowCoveringClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWindowCoveringClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWindowCoveringClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterWindowCoveringClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWindowCoveringClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Service Area Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfServiceAreaClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterServiceAreaClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfServiceAreaClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterServiceAreaClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterServiceAreaClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfServiceAreaClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Pump Configuration and Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPumpConfigurationAndControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPumpConfigurationAndControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPumpConfigurationAndControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPumpConfigurationAndControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPumpConfigurationAndControlClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPumpConfigurationAndControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Thermostat Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThermostatClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterThermostatClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThermostatClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterThermostatClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterThermostatClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfThermostatClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Fan Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFanControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterFanControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFanControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterFanControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterFanControlClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfFanControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Thermostat User Interface Configuration Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThermostatUserInterfaceConfigurationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterThermostatUserInterfaceConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThermostatUserInterfaceConfigurationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterThermostatUserInterfaceConfigurationClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterThermostatUserInterfaceConfigurationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfThermostatUserInterfaceConfigurationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Color Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfColorControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterColorControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfColorControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterColorControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterColorControlClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfColorControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Ballast Configuration Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBallastConfigurationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterBallastConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfBallastConfigurationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterBallastConfigurationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterBallastConfigurationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfBallastConfigurationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Illuminance Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIlluminanceMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterIlluminanceMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfIlluminanceMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterIlluminanceMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterIlluminanceMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfIlluminanceMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Temperature Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTemperatureMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTemperatureMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTemperatureMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTemperatureMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterTemperatureMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTemperatureMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Pressure Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPressureMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPressureMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPressureMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPressureMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPressureMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPressureMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Flow Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFlowMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterFlowMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFlowMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterFlowMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterFlowMeasurementClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfFlowMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Relative Humidity Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRelativeHumidityMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRelativeHumidityMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRelativeHumidityMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRelativeHumidityMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterRelativeHumidityMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRelativeHumidityMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Occupancy Sensing Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOccupancySensingClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOccupancySensingClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOccupancySensingClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOccupancySensingClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterOccupancySensingClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOccupancySensingClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Carbon Monoxide Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCarbonMonoxideConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterCarbonMonoxideConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCarbonMonoxideConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterCarbonMonoxideConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterCarbonMonoxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfCarbonMonoxideConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Carbon Dioxide Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCarbonDioxideConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterCarbonDioxideConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCarbonDioxideConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterCarbonDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterCarbonDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfCarbonDioxideConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Nitrogen Dioxide Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfNitrogenDioxideConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterNitrogenDioxideConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfNitrogenDioxideConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterNitrogenDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterNitrogenDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfNitrogenDioxideConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Ozone Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOzoneConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterOzoneConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfOzoneConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterOzoneConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterOzoneConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfOzoneConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// PM2.5 Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm25ConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPm25ConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm25ConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPm25ConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPm25ConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPm25ConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Formaldehyde Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFormaldehydeConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterFormaldehydeConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFormaldehydeConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterFormaldehydeConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterFormaldehydeConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfFormaldehydeConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// PM1 Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm1ConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPm1ConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm1ConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPm1ConcentrationMeasurementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPm1ConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPm1ConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// PM10 Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm10ConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterPm10ConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfPm10ConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterPm10ConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterPm10ConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfPm10ConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Total Volatile Organic Compounds Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTotalVolatileOrganicCompoundsConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Radon Concentration Measurement Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRadonConcentrationMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRadonConcentrationMeasurementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRadonConcentrationMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRadonConcentrationMeasurementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterRadonConcentrationMeasurementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRadonConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Wi-Fi Network Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWiFiNetworkManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWiFiNetworkManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWiFiNetworkManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWiFiNetworkManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterWiFiNetworkManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWiFiNetworkManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Thread Border Router Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadBorderRouterManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterThreadBorderRouterManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadBorderRouterManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterThreadBorderRouterManagementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterThreadBorderRouterManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfThreadBorderRouterManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Thread Network Directory Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadNetworkDirectoryClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterThreadNetworkDirectoryClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfThreadNetworkDirectoryClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterThreadNetworkDirectoryClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterThreadNetworkDirectoryClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfThreadNetworkDirectoryClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Wake on LAN Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWakeOnLanClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWakeOnLanClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWakeOnLanClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWakeOnLanClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterWakeOnLanClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWakeOnLanClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Channel Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfChannelClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterChannelClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfChannelClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterChannelClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterChannelClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfChannelClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Target Navigator Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTargetNavigatorClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterTargetNavigatorClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfTargetNavigatorClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterTargetNavigatorClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterTargetNavigatorClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfTargetNavigatorClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Media Playback Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMediaPlaybackClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterMediaPlaybackClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMediaPlaybackClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterMediaPlaybackClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterMediaPlaybackClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfMediaPlaybackClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Media Input Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMediaInputClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterMediaInputClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfMediaInputClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterMediaInputClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterMediaInputClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfMediaInputClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Low Power Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLowPowerClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterLowPowerClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfLowPowerClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterLowPowerClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterLowPowerClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfLowPowerClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Keypad Input Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfKeypadInputClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterKeypadInputClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfKeypadInputClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterKeypadInputClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterKeypadInputClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfKeypadInputClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Content Launcher Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentLauncherClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterContentLauncherClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentLauncherClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterContentLauncherClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterContentLauncherClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfContentLauncherClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Audio Output Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAudioOutputClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterAudioOutputClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAudioOutputClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterAudioOutputClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterAudioOutputClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfAudioOutputClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Application Launcher Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfApplicationLauncherClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterApplicationLauncherClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfApplicationLauncherClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterApplicationLauncherClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterApplicationLauncherClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfApplicationLauncherClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Application Basic Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfApplicationBasicClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterApplicationBasicClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfApplicationBasicClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterApplicationBasicClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterApplicationBasicClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfApplicationBasicClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Account Login Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAccountLoginClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterAccountLoginClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfAccountLoginClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterAccountLoginClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterAccountLoginClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfAccountLoginClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Content Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterContentControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterContentControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterContentControlClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfContentControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Content App Observer Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentAppObserverClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterContentAppObserverClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfContentAppObserverClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterContentAppObserverClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterContentAppObserverClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfContentAppObserverClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Zone Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfZoneManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterZoneManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfZoneManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterZoneManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterZoneManagementClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfZoneManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Camera AV Stream Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCameraAvStreamManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterCameraAvStreamManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCameraAvStreamManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterCameraAvStreamManagementClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterCameraAvStreamManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfCameraAvStreamManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Camera AV Settings User Level Management Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCameraAvSettingsUserLevelManagementClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterCameraAvSettingsUserLevelManagementClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCameraAvSettingsUserLevelManagementClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterCameraAvSettingsUserLevelManagementClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterCameraAvSettingsUserLevelManagementClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfCameraAvSettingsUserLevelManagementClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// WebRTC Transport Provider Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWebRTCTransportProviderClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWebRTCTransportProviderClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWebRTCTransportProviderClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWebRTCTransportProviderClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterWebRTCTransportProviderClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWebRTCTransportProviderClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// WebRTC Transport Requestor Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWebRTCTransportRequestorClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterWebRTCTransportRequestorClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfWebRTCTransportRequestorClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterWebRTCTransportRequestorClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterWebRTCTransportRequestorClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfWebRTCTransportRequestorClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Chime Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfChimeClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterChimeClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfChimeClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterChimeClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterChimeClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfChimeClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Ecosystem Information Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEcosystemInformationClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterEcosystemInformationClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfEcosystemInformationClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterEcosystemInformationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterEcosystemInformationClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfEcosystemInformationClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Commissioner Control Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCommissionerControlClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterCommissionerControlClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfCommissionerControlClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterCommissionerControlClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterCommissionerControlClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfCommissionerControlClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Unit Testing Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUnitTestingClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterUnitTestingClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfUnitTestingClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterUnitTestingClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterUnitTestingClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfUnitTestingClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Fault Injection Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFaultInjectionClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterFaultInjectionClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfFaultInjectionClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterFaultInjectionClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterFaultInjectionClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfFaultInjectionClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Sample Manufacturer-Specific Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSampleManufacturerSpecificClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterSampleManufacturerSpecificClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSampleManufacturerSpecificClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterSampleManufacturerSpecificClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterSampleManufacturerSpecificClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfSampleManufacturerSpecificClusterServerTickCallback(chip::EndpointId endpoint);
+
+//
+// Sample External manufacturer-specific Cluster
+//
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSampleExternalManufacturerSpecificClusterServerInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterSampleExternalManufacturerSpecificClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/**
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfSampleExternalManufacturerSpecificClusterClientInitCallback(chip::EndpointId endpoint);
+
+/**
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterSampleExternalManufacturerSpecificClusterServerAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath);
+
+/**
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status MatterSampleExternalManufacturerSpecificClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/**
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfSampleExternalManufacturerSpecificClusterServerTickCallback(chip::EndpointId endpoint);
+
+// Cluster Commands Callback
+
+/**
+ * @brief Identify Cluster Identify Command callback (from client)
+ */
+bool emberAfIdentifyClusterIdentifyCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Identify::Commands::Identify::DecodableType & commandData);
+/**
+ * @brief Identify Cluster TriggerEffect Command callback (from client)
+ */
+bool emberAfIdentifyClusterTriggerEffectCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Identify::Commands::TriggerEffect::DecodableType & commandData);
+/**
+ * @brief Groups Cluster AddGroup Command callback (from client)
+ */
+bool emberAfGroupsClusterAddGroupCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Groups::Commands::AddGroup::DecodableType & commandData);
+/**
+ * @brief Groups Cluster ViewGroup Command callback (from client)
+ */
+bool emberAfGroupsClusterViewGroupCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Groups::Commands::ViewGroup::DecodableType & commandData);
+/**
+ * @brief Groups Cluster GetGroupMembership Command callback (from client)
+ */
+bool emberAfGroupsClusterGetGroupMembershipCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Groups::Commands::GetGroupMembership::DecodableType & commandData);
+/**
+ * @brief Groups Cluster RemoveGroup Command callback (from client)
+ */
+bool emberAfGroupsClusterRemoveGroupCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Groups::Commands::RemoveGroup::DecodableType & commandData);
+/**
+ * @brief Groups Cluster RemoveAllGroups Command callback (from client)
+ */
+bool emberAfGroupsClusterRemoveAllGroupsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Groups::Commands::RemoveAllGroups::DecodableType & commandData);
+/**
+ * @brief Groups Cluster AddGroupIfIdentifying Command callback (from client)
+ */
+bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::DecodableType & commandData);
+/**
+ * @brief On/Off Cluster Off Command callback (from client)
+ */
+bool emberAfOnOffClusterOffCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OnOff::Commands::Off::DecodableType & commandData);
+/**
+ * @brief On/Off Cluster On Command callback (from client)
+ */
+bool emberAfOnOffClusterOnCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OnOff::Commands::On::DecodableType & commandData);
+/**
+ * @brief On/Off Cluster Toggle Command callback (from client)
+ */
+bool emberAfOnOffClusterToggleCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OnOff::Commands::Toggle::DecodableType & commandData);
+/**
+ * @brief On/Off Cluster OffWithEffect Command callback (from client)
+ */
+bool emberAfOnOffClusterOffWithEffectCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OnOff::Commands::OffWithEffect::DecodableType & commandData);
+/**
+ * @brief On/Off Cluster OnWithRecallGlobalScene Command callback (from client)
+ */
+bool emberAfOnOffClusterOnWithRecallGlobalSceneCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OnOff::Commands::OnWithRecallGlobalScene::DecodableType & commandData);
+/**
+ * @brief On/Off Cluster OnWithTimedOff Command callback (from client)
+ */
+bool emberAfOnOffClusterOnWithTimedOffCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OnOff::Commands::OnWithTimedOff::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster MoveToLevel Command callback (from client)
+ */
+bool emberAfLevelControlClusterMoveToLevelCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::MoveToLevel::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster Move Command callback (from client)
+ */
+bool emberAfLevelControlClusterMoveCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::Move::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster Step Command callback (from client)
+ */
+bool emberAfLevelControlClusterStepCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::Step::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster Stop Command callback (from client)
+ */
+bool emberAfLevelControlClusterStopCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::Stop::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster MoveToLevelWithOnOff Command callback (from client)
+ */
+bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::MoveToLevelWithOnOff::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster MoveWithOnOff Command callback (from client)
+ */
+bool emberAfLevelControlClusterMoveWithOnOffCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::MoveWithOnOff::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster StepWithOnOff Command callback (from client)
+ */
+bool emberAfLevelControlClusterStepWithOnOffCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::StepWithOnOff::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster StopWithOnOff Command callback (from client)
+ */
+bool emberAfLevelControlClusterStopWithOnOffCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::StopWithOnOff::DecodableType & commandData);
+/**
+ * @brief Level Control Cluster MoveToClosestFrequency Command callback (from client)
+ */
+bool emberAfLevelControlClusterMoveToClosestFrequencyCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LevelControl::Commands::MoveToClosestFrequency::DecodableType & commandData);
+/**
+ * @brief Access Control Cluster ReviewFabricRestrictions Command callback (from client)
+ */
+bool emberAfAccessControlClusterReviewFabricRestrictionsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AccessControl::Commands::ReviewFabricRestrictions::DecodableType & commandData);
+/**
+ * @brief Actions Cluster InstantAction Command callback (from client)
+ */
+bool emberAfActionsClusterInstantActionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::InstantAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster InstantActionWithTransition Command callback (from client)
+ */
+bool emberAfActionsClusterInstantActionWithTransitionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::InstantActionWithTransition::DecodableType & commandData);
+/**
+ * @brief Actions Cluster StartAction Command callback (from client)
+ */
+bool emberAfActionsClusterStartActionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::StartAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster StartActionWithDuration Command callback (from client)
+ */
+bool emberAfActionsClusterStartActionWithDurationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::StartActionWithDuration::DecodableType & commandData);
+/**
+ * @brief Actions Cluster StopAction Command callback (from client)
+ */
+bool emberAfActionsClusterStopActionCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::StopAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster PauseAction Command callback (from client)
+ */
+bool emberAfActionsClusterPauseActionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::PauseAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster PauseActionWithDuration Command callback (from client)
+ */
+bool emberAfActionsClusterPauseActionWithDurationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::PauseActionWithDuration::DecodableType & commandData);
+/**
+ * @brief Actions Cluster ResumeAction Command callback (from client)
+ */
+bool emberAfActionsClusterResumeActionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::ResumeAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster EnableAction Command callback (from client)
+ */
+bool emberAfActionsClusterEnableActionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::EnableAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster EnableActionWithDuration Command callback (from client)
+ */
+bool emberAfActionsClusterEnableActionWithDurationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::EnableActionWithDuration::DecodableType & commandData);
+/**
+ * @brief Actions Cluster DisableAction Command callback (from client)
+ */
+bool emberAfActionsClusterDisableActionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::DisableAction::DecodableType & commandData);
+/**
+ * @brief Actions Cluster DisableActionWithDuration Command callback (from client)
+ */
+bool emberAfActionsClusterDisableActionWithDurationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Actions::Commands::DisableActionWithDuration::DecodableType & commandData);
+/**
+ * @brief Basic Information Cluster MfgSpecificPing Command callback (from client)
+ */
+bool emberAfBasicInformationClusterMfgSpecificPingCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::BasicInformation::Commands::MfgSpecificPing::DecodableType & commandData);
+/**
+ * @brief OTA Software Update Provider Cluster QueryImage Command callback (from client)
+ */
+bool emberAfOtaSoftwareUpdateProviderClusterQueryImageCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::DecodableType & commandData);
+/**
+ * @brief OTA Software Update Provider Cluster ApplyUpdateRequest Command callback (from client)
+ */
+bool emberAfOtaSoftwareUpdateProviderClusterApplyUpdateRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::DecodableType & commandData);
+/**
+ * @brief OTA Software Update Provider Cluster NotifyUpdateApplied Command callback (from client)
+ */
+bool emberAfOtaSoftwareUpdateProviderClusterNotifyUpdateAppliedCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::DecodableType & commandData);
+/**
+ * @brief OTA Software Update Requestor Cluster AnnounceOTAProvider Command callback (from client)
+ */
+bool emberAfOtaSoftwareUpdateRequestorClusterAnnounceOTAProviderCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOTAProvider::DecodableType & commandData);
+/**
+ * @brief General Commissioning Cluster ArmFailSafe Command callback (from client)
+ */
+bool emberAfGeneralCommissioningClusterArmFailSafeCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafe::DecodableType & commandData);
+/**
+ * @brief General Commissioning Cluster SetRegulatoryConfig Command callback (from client)
+ */
+bool emberAfGeneralCommissioningClusterSetRegulatoryConfigCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfig::DecodableType & commandData);
+/**
+ * @brief General Commissioning Cluster CommissioningComplete Command callback (from client)
+ */
+bool emberAfGeneralCommissioningClusterCommissioningCompleteCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralCommissioning::Commands::CommissioningComplete::DecodableType & commandData);
+/**
+ * @brief General Commissioning Cluster SetTCAcknowledgements Command callback (from client)
+ */
+bool emberAfGeneralCommissioningClusterSetTCAcknowledgementsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralCommissioning::Commands::SetTCAcknowledgements::DecodableType & commandData);
+/**
+ * @brief Diagnostic Logs Cluster RetrieveLogsRequest Command callback (from client)
+ */
+bool emberAfDiagnosticLogsClusterRetrieveLogsRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsRequest::DecodableType & commandData);
+/**
+ * @brief General Diagnostics Cluster TestEventTrigger Command callback (from client)
+ */
+bool emberAfGeneralDiagnosticsClusterTestEventTriggerCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralDiagnostics::Commands::TestEventTrigger::DecodableType & commandData);
+/**
+ * @brief General Diagnostics Cluster TimeSnapshot Command callback (from client)
+ */
+bool emberAfGeneralDiagnosticsClusterTimeSnapshotCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralDiagnostics::Commands::TimeSnapshot::DecodableType & commandData);
+/**
+ * @brief General Diagnostics Cluster PayloadTestRequest Command callback (from client)
+ */
+bool emberAfGeneralDiagnosticsClusterPayloadTestRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GeneralDiagnostics::Commands::PayloadTestRequest::DecodableType & commandData);
+/**
+ * @brief Software Diagnostics Cluster ResetWatermarks Command callback (from client)
+ */
+bool emberAfSoftwareDiagnosticsClusterResetWatermarksCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::SoftwareDiagnostics::Commands::ResetWatermarks::DecodableType & commandData);
+/**
+ * @brief Thread Network Diagnostics Cluster ResetCounts Command callback (from client)
+ */
+bool emberAfThreadNetworkDiagnosticsClusterResetCountsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ThreadNetworkDiagnostics::Commands::ResetCounts::DecodableType & commandData);
+/**
+ * @brief Wi-Fi Network Diagnostics Cluster ResetCounts Command callback (from client)
+ */
+bool emberAfWiFiNetworkDiagnosticsClusterResetCountsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WiFiNetworkDiagnostics::Commands::ResetCounts::DecodableType & commandData);
+/**
+ * @brief Ethernet Network Diagnostics Cluster ResetCounts Command callback (from client)
+ */
+bool emberAfEthernetNetworkDiagnosticsClusterResetCountsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::DecodableType & commandData);
+/**
+ * @brief Time Synchronization Cluster SetUTCTime Command callback (from client)
+ */
+bool emberAfTimeSynchronizationClusterSetUTCTimeCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TimeSynchronization::Commands::SetUTCTime::DecodableType & commandData);
+/**
+ * @brief Time Synchronization Cluster SetTrustedTimeSource Command callback (from client)
+ */
+bool emberAfTimeSynchronizationClusterSetTrustedTimeSourceCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::DecodableType & commandData);
+/**
+ * @brief Time Synchronization Cluster SetTimeZone Command callback (from client)
+ */
+bool emberAfTimeSynchronizationClusterSetTimeZoneCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TimeSynchronization::Commands::SetTimeZone::DecodableType & commandData);
+/**
+ * @brief Time Synchronization Cluster SetDSTOffset Command callback (from client)
+ */
+bool emberAfTimeSynchronizationClusterSetDSTOffsetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TimeSynchronization::Commands::SetDSTOffset::DecodableType & commandData);
+/**
+ * @brief Time Synchronization Cluster SetDefaultNTP Command callback (from client)
+ */
+bool emberAfTimeSynchronizationClusterSetDefaultNTPCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TimeSynchronization::Commands::SetDefaultNTP::DecodableType & commandData);
+/**
+ * @brief Bridged Device Basic Information Cluster KeepActive Command callback (from client)
+ */
+bool emberAfBridgedDeviceBasicInformationClusterKeepActiveCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::BridgedDeviceBasicInformation::Commands::KeepActive::DecodableType & commandData);
+/**
+ * @brief Administrator Commissioning Cluster OpenCommissioningWindow Command callback (from client)
+ */
+bool emberAfAdministratorCommissioningClusterOpenCommissioningWindowCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::DecodableType & commandData);
+/**
+ * @brief Administrator Commissioning Cluster OpenBasicCommissioningWindow Command callback (from client)
+ */
+bool emberAfAdministratorCommissioningClusterOpenBasicCommissioningWindowCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::DecodableType & commandData);
+/**
+ * @brief Administrator Commissioning Cluster RevokeCommissioning Command callback (from client)
+ */
+bool emberAfAdministratorCommissioningClusterRevokeCommissioningCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster AttestationRequest Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterAttestationRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::AttestationRequest::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster CertificateChainRequest Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterCertificateChainRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::CertificateChainRequest::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster CSRRequest Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterCSRRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::CSRRequest::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster AddNOC Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterAddNOCCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::AddNOC::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster UpdateNOC Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterUpdateNOCCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster UpdateFabricLabel Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterUpdateFabricLabelCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster RemoveFabric Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterRemoveFabricCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::RemoveFabric::DecodableType & commandData);
+/**
+ * @brief Operational Credentials Cluster AddTrustedRootCertificate Command callback (from client)
+ */
+bool emberAfOperationalCredentialsClusterAddTrustedRootCertificateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::OperationalCredentials::Commands::AddTrustedRootCertificate::DecodableType & commandData);
+/**
+ * @brief Group Key Management Cluster KeySetWrite Command callback (from client)
+ */
+bool emberAfGroupKeyManagementClusterKeySetWriteCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::DecodableType & commandData);
+/**
+ * @brief Group Key Management Cluster KeySetRead Command callback (from client)
+ */
+bool emberAfGroupKeyManagementClusterKeySetReadCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::DecodableType & commandData);
+/**
+ * @brief Group Key Management Cluster KeySetRemove Command callback (from client)
+ */
+bool emberAfGroupKeyManagementClusterKeySetRemoveCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::DecodableType & commandData);
+/**
+ * @brief Group Key Management Cluster KeySetReadAllIndices Command callback (from client)
+ */
+bool emberAfGroupKeyManagementClusterKeySetReadAllIndicesCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::DecodableType & commandData);
+/**
+ * @brief ICD Management Cluster RegisterClient Command callback (from client)
+ */
+bool emberAfIcdManagementClusterRegisterClientCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::IcdManagement::Commands::RegisterClient::DecodableType & commandData);
+/**
+ * @brief ICD Management Cluster UnregisterClient Command callback (from client)
+ */
+bool emberAfIcdManagementClusterUnregisterClientCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::IcdManagement::Commands::UnregisterClient::DecodableType & commandData);
+/**
+ * @brief ICD Management Cluster StayActiveRequest Command callback (from client)
+ */
+bool emberAfIcdManagementClusterStayActiveRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::IcdManagement::Commands::StayActiveRequest::DecodableType & commandData);
+/**
+ * @brief Timer Cluster SetTimer Command callback (from client)
+ */
+bool emberAfTimerClusterSetTimerCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Timer::Commands::SetTimer::DecodableType & commandData);
+/**
+ * @brief Timer Cluster ResetTimer Command callback (from client)
+ */
+bool emberAfTimerClusterResetTimerCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Timer::Commands::ResetTimer::DecodableType & commandData);
+/**
+ * @brief Timer Cluster AddTime Command callback (from client)
+ */
+bool emberAfTimerClusterAddTimeCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Timer::Commands::AddTime::DecodableType & commandData);
+/**
+ * @brief Timer Cluster ReduceTime Command callback (from client)
+ */
+bool emberAfTimerClusterReduceTimeCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Timer::Commands::ReduceTime::DecodableType & commandData);
+/**
+ * @brief Mode Select Cluster ChangeToMode Command callback (from client)
+ */
+bool emberAfModeSelectClusterChangeToModeCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ModeSelect::Commands::ChangeToMode::DecodableType & commandData);
+/**
+ * @brief Temperature Control Cluster SetTemperature Command callback (from client)
+ */
+bool emberAfTemperatureControlClusterSetTemperatureCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TemperatureControl::Commands::SetTemperature::DecodableType & commandData);
+/**
+ * @brief Smoke CO Alarm Cluster SelfTestRequest Command callback (from client)
+ */
+bool emberAfSmokeCoAlarmClusterSelfTestRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::DecodableType & commandData);
+/**
+ * @brief Dishwasher Alarm Cluster Reset Command callback (from client)
+ */
+bool emberAfDishwasherAlarmClusterResetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DishwasherAlarm::Commands::Reset::DecodableType & commandData);
+/**
+ * @brief Dishwasher Alarm Cluster ModifyEnabledAlarms Command callback (from client)
+ */
+bool emberAfDishwasherAlarmClusterModifyEnabledAlarmsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DishwasherAlarm::Commands::ModifyEnabledAlarms::DecodableType & commandData);
+/**
+ * @brief Boolean State Configuration Cluster SuppressAlarm Command callback (from client)
+ */
+bool emberAfBooleanStateConfigurationClusterSuppressAlarmCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::BooleanStateConfiguration::Commands::SuppressAlarm::DecodableType & commandData);
+/**
+ * @brief Boolean State Configuration Cluster EnableDisableAlarm Command callback (from client)
+ */
+bool emberAfBooleanStateConfigurationClusterEnableDisableAlarmCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::BooleanStateConfiguration::Commands::EnableDisableAlarm::DecodableType & commandData);
+/**
+ * @brief Valve Configuration and Control Cluster Open Command callback (from client)
+ */
+bool emberAfValveConfigurationAndControlClusterOpenCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::DecodableType & commandData);
+/**
+ * @brief Valve Configuration and Control Cluster Close Command callback (from client)
+ */
+bool emberAfValveConfigurationAndControlClusterCloseCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::DecodableType & commandData);
+/**
+ * @brief Demand Response Load Control Cluster RegisterLoadControlProgramRequest Command callback (from client)
+ */
+bool emberAfDemandResponseLoadControlClusterRegisterLoadControlProgramRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DemandResponseLoadControl::Commands::RegisterLoadControlProgramRequest::DecodableType & commandData);
+/**
+ * @brief Demand Response Load Control Cluster UnregisterLoadControlProgramRequest Command callback (from client)
+ */
+bool emberAfDemandResponseLoadControlClusterUnregisterLoadControlProgramRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DemandResponseLoadControl::Commands::UnregisterLoadControlProgramRequest::DecodableType &
+ commandData);
+/**
+ * @brief Demand Response Load Control Cluster AddLoadControlEventRequest Command callback (from client)
+ */
+bool emberAfDemandResponseLoadControlClusterAddLoadControlEventRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DemandResponseLoadControl::Commands::AddLoadControlEventRequest::DecodableType & commandData);
+/**
+ * @brief Demand Response Load Control Cluster RemoveLoadControlEventRequest Command callback (from client)
+ */
+bool emberAfDemandResponseLoadControlClusterRemoveLoadControlEventRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DemandResponseLoadControl::Commands::RemoveLoadControlEventRequest::DecodableType & commandData);
+/**
+ * @brief Demand Response Load Control Cluster ClearLoadControlEventsRequest Command callback (from client)
+ */
+bool emberAfDemandResponseLoadControlClusterClearLoadControlEventsRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DemandResponseLoadControl::Commands::ClearLoadControlEventsRequest::DecodableType & commandData);
+/**
+ * @brief Messages Cluster PresentMessagesRequest Command callback (from client)
+ */
+bool emberAfMessagesClusterPresentMessagesRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Messages::Commands::PresentMessagesRequest::DecodableType & commandData);
+/**
+ * @brief Messages Cluster CancelMessagesRequest Command callback (from client)
+ */
+bool emberAfMessagesClusterCancelMessagesRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Messages::Commands::CancelMessagesRequest::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster LockDoor Command callback (from client)
+ */
+bool emberAfDoorLockClusterLockDoorCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::LockDoor::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster UnlockDoor Command callback (from client)
+ */
+bool emberAfDoorLockClusterUnlockDoorCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::UnlockDoor::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster UnlockWithTimeout Command callback (from client)
+ */
+bool emberAfDoorLockClusterUnlockWithTimeoutCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster SetWeekDaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterSetWeekDayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::SetWeekDaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster GetWeekDaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterGetWeekDayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::GetWeekDaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster ClearWeekDaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterClearWeekDayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::ClearWeekDaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster SetYearDaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterSetYearDayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::SetYearDaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster GetYearDaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterGetYearDayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::GetYearDaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster ClearYearDaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterClearYearDayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::ClearYearDaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster SetHolidaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterSetHolidayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::SetHolidaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster GetHolidaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterGetHolidayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::GetHolidaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster ClearHolidaySchedule Command callback (from client)
+ */
+bool emberAfDoorLockClusterClearHolidayScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::ClearHolidaySchedule::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster SetUser Command callback (from client)
+ */
+bool emberAfDoorLockClusterSetUserCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::SetUser::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster GetUser Command callback (from client)
+ */
+bool emberAfDoorLockClusterGetUserCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::GetUser::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster ClearUser Command callback (from client)
+ */
+bool emberAfDoorLockClusterClearUserCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::ClearUser::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster SetCredential Command callback (from client)
+ */
+bool emberAfDoorLockClusterSetCredentialCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::SetCredential::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster GetCredentialStatus Command callback (from client)
+ */
+bool emberAfDoorLockClusterGetCredentialStatusCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::GetCredentialStatus::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster ClearCredential Command callback (from client)
+ */
+bool emberAfDoorLockClusterClearCredentialCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::ClearCredential::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster UnboltDoor Command callback (from client)
+ */
+bool emberAfDoorLockClusterUnboltDoorCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::UnboltDoor::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster SetAliroReaderConfig Command callback (from client)
+ */
+bool emberAfDoorLockClusterSetAliroReaderConfigCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::SetAliroReaderConfig::DecodableType & commandData);
+/**
+ * @brief Door Lock Cluster ClearAliroReaderConfig Command callback (from client)
+ */
+bool emberAfDoorLockClusterClearAliroReaderConfigCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::DoorLock::Commands::ClearAliroReaderConfig::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster UpOrOpen Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterUpOrOpenCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::UpOrOpen::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster DownOrClose Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterDownOrCloseCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::DownOrClose::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster StopMotion Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterStopMotionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::StopMotion::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster GoToLiftValue Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterGoToLiftValueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::GoToLiftValue::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster GoToLiftPercentage Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterGoToLiftPercentageCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::GoToLiftPercentage::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster GoToTiltValue Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterGoToTiltValueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::GoToTiltValue::DecodableType & commandData);
+/**
+ * @brief Window Covering Cluster GoToTiltPercentage Command callback (from client)
+ */
+bool emberAfWindowCoveringClusterGoToTiltPercentageCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WindowCovering::Commands::GoToTiltPercentage::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster SetpointRaiseLower Command callback (from client)
+ */
+bool emberAfThermostatClusterSetpointRaiseLowerCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::SetpointRaiseLower::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster SetWeeklySchedule Command callback (from client)
+ */
+bool emberAfThermostatClusterSetWeeklyScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::SetWeeklySchedule::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster GetWeeklySchedule Command callback (from client)
+ */
+bool emberAfThermostatClusterGetWeeklyScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::GetWeeklySchedule::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster ClearWeeklySchedule Command callback (from client)
+ */
+bool emberAfThermostatClusterClearWeeklyScheduleCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::ClearWeeklySchedule::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster SetActiveScheduleRequest Command callback (from client)
+ */
+bool emberAfThermostatClusterSetActiveScheduleRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::SetActiveScheduleRequest::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster SetActivePresetRequest Command callback (from client)
+ */
+bool emberAfThermostatClusterSetActivePresetRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::SetActivePresetRequest::DecodableType & commandData);
+/**
+ * @brief Thermostat Cluster AtomicRequest Command callback (from client)
+ */
+bool emberAfThermostatClusterAtomicRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Thermostat::Commands::AtomicRequest::DecodableType & commandData);
+/**
+ * @brief Fan Control Cluster Step Command callback (from client)
+ */
+bool emberAfFanControlClusterStepCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::FanControl::Commands::Step::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveToHue Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveToHueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveToHue::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveHue Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveHueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveHue::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster StepHue Command callback (from client)
+ */
+bool emberAfColorControlClusterStepHueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::StepHue::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveToSaturation Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveToSaturationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveToSaturation::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveSaturation Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveSaturationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveSaturation::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster StepSaturation Command callback (from client)
+ */
+bool emberAfColorControlClusterStepSaturationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::StepSaturation::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveToHueAndSaturation Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveToHueAndSaturationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveToHueAndSaturation::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveToColor Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveToColorCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveToColor::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveColor Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveColorCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveColor::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster StepColor Command callback (from client)
+ */
+bool emberAfColorControlClusterStepColorCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::StepColor::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveToColorTemperature Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveToColorTemperatureCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveToColorTemperature::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster EnhancedMoveToHue Command callback (from client)
+ */
+bool emberAfColorControlClusterEnhancedMoveToHueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHue::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster EnhancedMoveHue Command callback (from client)
+ */
+bool emberAfColorControlClusterEnhancedMoveHueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::EnhancedMoveHue::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster EnhancedStepHue Command callback (from client)
+ */
+bool emberAfColorControlClusterEnhancedStepHueCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::EnhancedStepHue::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster EnhancedMoveToHueAndSaturation Command callback (from client)
+ */
+bool emberAfColorControlClusterEnhancedMoveToHueAndSaturationCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster ColorLoopSet Command callback (from client)
+ */
+bool emberAfColorControlClusterColorLoopSetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::ColorLoopSet::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster StopMoveStep Command callback (from client)
+ */
+bool emberAfColorControlClusterStopMoveStepCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::StopMoveStep::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster MoveColorTemperature Command callback (from client)
+ */
+bool emberAfColorControlClusterMoveColorTemperatureCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::MoveColorTemperature::DecodableType & commandData);
+/**
+ * @brief Color Control Cluster StepColorTemperature Command callback (from client)
+ */
+bool emberAfColorControlClusterStepColorTemperatureCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ColorControl::Commands::StepColorTemperature::DecodableType & commandData);
+/**
+ * @brief Channel Cluster ChangeChannel Command callback (from client)
+ */
+bool emberAfChannelClusterChangeChannelCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Channel::Commands::ChangeChannel::DecodableType & commandData);
+/**
+ * @brief Channel Cluster ChangeChannelByNumber Command callback (from client)
+ */
+bool emberAfChannelClusterChangeChannelByNumberCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Channel::Commands::ChangeChannelByNumber::DecodableType & commandData);
+/**
+ * @brief Channel Cluster SkipChannel Command callback (from client)
+ */
+bool emberAfChannelClusterSkipChannelCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Channel::Commands::SkipChannel::DecodableType & commandData);
+/**
+ * @brief Channel Cluster GetProgramGuide Command callback (from client)
+ */
+bool emberAfChannelClusterGetProgramGuideCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Channel::Commands::GetProgramGuide::DecodableType & commandData);
+/**
+ * @brief Channel Cluster RecordProgram Command callback (from client)
+ */
+bool emberAfChannelClusterRecordProgramCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Channel::Commands::RecordProgram::DecodableType & commandData);
+/**
+ * @brief Channel Cluster CancelRecordProgram Command callback (from client)
+ */
+bool emberAfChannelClusterCancelRecordProgramCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::Channel::Commands::CancelRecordProgram::DecodableType & commandData);
+/**
+ * @brief Target Navigator Cluster NavigateTarget Command callback (from client)
+ */
+bool emberAfTargetNavigatorClusterNavigateTargetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::TargetNavigator::Commands::NavigateTarget::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Play Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterPlayCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Play::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Pause Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterPauseCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Pause::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Stop Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterStopCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Stop::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster StartOver Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterStartOverCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::StartOver::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Previous Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterPreviousCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Previous::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Next Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterNextCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Next::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Rewind Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterRewindCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Rewind::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster FastForward Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterFastForwardCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::FastForward::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster SkipForward Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterSkipForwardCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::SkipForward::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster SkipBackward Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterSkipBackwardCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::SkipBackward::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster Seek Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterSeekCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::Seek::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster ActivateAudioTrack Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterActivateAudioTrackCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::ActivateAudioTrack::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster ActivateTextTrack Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterActivateTextTrackCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::ActivateTextTrack::DecodableType & commandData);
+/**
+ * @brief Media Playback Cluster DeactivateTextTrack Command callback (from client)
+ */
+bool emberAfMediaPlaybackClusterDeactivateTextTrackCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaPlayback::Commands::DeactivateTextTrack::DecodableType & commandData);
+/**
+ * @brief Media Input Cluster SelectInput Command callback (from client)
+ */
+bool emberAfMediaInputClusterSelectInputCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaInput::Commands::SelectInput::DecodableType & commandData);
+/**
+ * @brief Media Input Cluster ShowInputStatus Command callback (from client)
+ */
+bool emberAfMediaInputClusterShowInputStatusCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaInput::Commands::ShowInputStatus::DecodableType & commandData);
+/**
+ * @brief Media Input Cluster HideInputStatus Command callback (from client)
+ */
+bool emberAfMediaInputClusterHideInputStatusCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaInput::Commands::HideInputStatus::DecodableType & commandData);
+/**
+ * @brief Media Input Cluster RenameInput Command callback (from client)
+ */
+bool emberAfMediaInputClusterRenameInputCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::MediaInput::Commands::RenameInput::DecodableType & commandData);
+/**
+ * @brief Low Power Cluster Sleep Command callback (from client)
+ */
+bool emberAfLowPowerClusterSleepCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::LowPower::Commands::Sleep::DecodableType & commandData);
+/**
+ * @brief Keypad Input Cluster SendKey Command callback (from client)
+ */
+bool emberAfKeypadInputClusterSendKeyCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::KeypadInput::Commands::SendKey::DecodableType & commandData);
+/**
+ * @brief Content Launcher Cluster LaunchContent Command callback (from client)
+ */
+bool emberAfContentLauncherClusterLaunchContentCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentLauncher::Commands::LaunchContent::DecodableType & commandData);
+/**
+ * @brief Content Launcher Cluster LaunchURL Command callback (from client)
+ */
+bool emberAfContentLauncherClusterLaunchURLCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentLauncher::Commands::LaunchURL::DecodableType & commandData);
+/**
+ * @brief Audio Output Cluster SelectOutput Command callback (from client)
+ */
+bool emberAfAudioOutputClusterSelectOutputCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AudioOutput::Commands::SelectOutput::DecodableType & commandData);
+/**
+ * @brief Audio Output Cluster RenameOutput Command callback (from client)
+ */
+bool emberAfAudioOutputClusterRenameOutputCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AudioOutput::Commands::RenameOutput::DecodableType & commandData);
+/**
+ * @brief Application Launcher Cluster LaunchApp Command callback (from client)
+ */
+bool emberAfApplicationLauncherClusterLaunchAppCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ApplicationLauncher::Commands::LaunchApp::DecodableType & commandData);
+/**
+ * @brief Application Launcher Cluster StopApp Command callback (from client)
+ */
+bool emberAfApplicationLauncherClusterStopAppCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ApplicationLauncher::Commands::StopApp::DecodableType & commandData);
+/**
+ * @brief Application Launcher Cluster HideApp Command callback (from client)
+ */
+bool emberAfApplicationLauncherClusterHideAppCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ApplicationLauncher::Commands::HideApp::DecodableType & commandData);
+/**
+ * @brief Account Login Cluster GetSetupPIN Command callback (from client)
+ */
+bool emberAfAccountLoginClusterGetSetupPINCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AccountLogin::Commands::GetSetupPIN::DecodableType & commandData);
+/**
+ * @brief Account Login Cluster Login Command callback (from client)
+ */
+bool emberAfAccountLoginClusterLoginCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AccountLogin::Commands::Login::DecodableType & commandData);
+/**
+ * @brief Account Login Cluster Logout Command callback (from client)
+ */
+bool emberAfAccountLoginClusterLogoutCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::AccountLogin::Commands::Logout::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster UpdatePIN Command callback (from client)
+ */
+bool emberAfContentControlClusterUpdatePINCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::UpdatePIN::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster ResetPIN Command callback (from client)
+ */
+bool emberAfContentControlClusterResetPINCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::ResetPIN::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster Enable Command callback (from client)
+ */
+bool emberAfContentControlClusterEnableCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::Enable::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster Disable Command callback (from client)
+ */
+bool emberAfContentControlClusterDisableCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::Disable::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster AddBonusTime Command callback (from client)
+ */
+bool emberAfContentControlClusterAddBonusTimeCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::AddBonusTime::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster SetScreenDailyTime Command callback (from client)
+ */
+bool emberAfContentControlClusterSetScreenDailyTimeCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::SetScreenDailyTime::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster BlockUnratedContent Command callback (from client)
+ */
+bool emberAfContentControlClusterBlockUnratedContentCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::BlockUnratedContent::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster UnblockUnratedContent Command callback (from client)
+ */
+bool emberAfContentControlClusterUnblockUnratedContentCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::UnblockUnratedContent::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster SetOnDemandRatingThreshold Command callback (from client)
+ */
+bool emberAfContentControlClusterSetOnDemandRatingThresholdCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::SetOnDemandRatingThreshold::DecodableType & commandData);
+/**
+ * @brief Content Control Cluster SetScheduledContentRatingThreshold Command callback (from client)
+ */
+bool emberAfContentControlClusterSetScheduledContentRatingThresholdCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentControl::Commands::SetScheduledContentRatingThreshold::DecodableType & commandData);
+/**
+ * @brief Content App Observer Cluster ContentAppMessage Command callback (from client)
+ */
+bool emberAfContentAppObserverClusterContentAppMessageCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ContentAppObserver::Commands::ContentAppMessage::DecodableType & commandData);
+/**
+ * @brief Zone Management Cluster CreateTwoDCartesianZone Command callback (from client)
+ */
+bool emberAfZoneManagementClusterCreateTwoDCartesianZoneCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ZoneManagement::Commands::CreateTwoDCartesianZone::DecodableType & commandData);
+/**
+ * @brief Zone Management Cluster UpdateTwoDCartesianZone Command callback (from client)
+ */
+bool emberAfZoneManagementClusterUpdateTwoDCartesianZoneCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ZoneManagement::Commands::UpdateTwoDCartesianZone::DecodableType & commandData);
+/**
+ * @brief Zone Management Cluster GetTwoDCartesianZone Command callback (from client)
+ */
+bool emberAfZoneManagementClusterGetTwoDCartesianZoneCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ZoneManagement::Commands::GetTwoDCartesianZone::DecodableType & commandData);
+/**
+ * @brief Zone Management Cluster RemoveZone Command callback (from client)
+ */
+bool emberAfZoneManagementClusterRemoveZoneCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::ZoneManagement::Commands::RemoveZone::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster AudioStreamAllocate Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterAudioStreamAllocateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::AudioStreamAllocate::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster AudioStreamDeallocate Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterAudioStreamDeallocateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::AudioStreamDeallocate::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster VideoStreamAllocate Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterVideoStreamAllocateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::VideoStreamAllocate::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster VideoStreamModify Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterVideoStreamModifyCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::VideoStreamModify::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster VideoStreamDeallocate Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterVideoStreamDeallocateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::VideoStreamDeallocate::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster SnapshotStreamAllocate Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterSnapshotStreamAllocateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::SnapshotStreamAllocate::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster SnapshotStreamDeallocate Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterSnapshotStreamDeallocateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::SnapshotStreamDeallocate::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster SetStreamPriorities Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterSetStreamPrioritiesCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::SetStreamPriorities::DecodableType & commandData);
+/**
+ * @brief Camera AV Stream Management Cluster CaptureSnapshot Command callback (from client)
+ */
+bool emberAfCameraAvStreamManagementClusterCaptureSnapshotCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvStreamManagement::Commands::CaptureSnapshot::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster MPTZSetPosition Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterMPTZSetPositionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::MPTZSetPosition::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster MPTZRelativeMove Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterMPTZRelativeMoveCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::MPTZRelativeMove::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster MPTZMoveToPreset Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterMPTZMoveToPresetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::MPTZMoveToPreset::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster MPTZSavePreset Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterMPTZSavePresetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::MPTZSavePreset::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster MPTZRemovePreset Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterMPTZRemovePresetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::MPTZRemovePreset::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster DPTZSetViewport Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterDPTZSetViewportCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::DPTZSetViewport::DecodableType & commandData);
+/**
+ * @brief Camera AV Settings User Level Management Cluster DPTZRelativeMove Command callback (from client)
+ */
+bool emberAfCameraAvSettingsUserLevelManagementClusterDPTZRelativeMoveCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Commands::DPTZRelativeMove::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Provider Cluster SolicitOffer Command callback (from client)
+ */
+bool emberAfWebRTCTransportProviderClusterSolicitOfferCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportProvider::Commands::SolicitOffer::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Provider Cluster ProvideOffer Command callback (from client)
+ */
+bool emberAfWebRTCTransportProviderClusterProvideOfferCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportProvider::Commands::ProvideOffer::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Provider Cluster ProvideAnswer Command callback (from client)
+ */
+bool emberAfWebRTCTransportProviderClusterProvideAnswerCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportProvider::Commands::ProvideAnswer::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Provider Cluster ProvideICECandidate Command callback (from client)
+ */
+bool emberAfWebRTCTransportProviderClusterProvideICECandidateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportProvider::Commands::ProvideICECandidate::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Provider Cluster EndSession Command callback (from client)
+ */
+bool emberAfWebRTCTransportProviderClusterEndSessionCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportProvider::Commands::EndSession::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Requestor Cluster Offer Command callback (from client)
+ */
+bool emberAfWebRTCTransportRequestorClusterOfferCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportRequestor::Commands::Offer::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Requestor Cluster Answer Command callback (from client)
+ */
+bool emberAfWebRTCTransportRequestorClusterAnswerCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportRequestor::Commands::Answer::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Requestor Cluster ICECandidate Command callback (from client)
+ */
+bool emberAfWebRTCTransportRequestorClusterICECandidateCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportRequestor::Commands::ICECandidate::DecodableType & commandData);
+/**
+ * @brief WebRTC Transport Requestor Cluster End Command callback (from client)
+ */
+bool emberAfWebRTCTransportRequestorClusterEndCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::WebRTCTransportRequestor::Commands::End::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster Test Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestCallback(chip::app::CommandHandler * commandObj,
+ const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::Test::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestNotHandled Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestNotHandledCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestNotHandled::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestSpecific Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestSpecificCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestSpecific::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestUnknownCommand Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestUnknownCommandCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestUnknownCommand::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestAddArguments Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestAddArgumentsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestAddArguments::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestSimpleArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestSimpleArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestSimpleArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestStructArrayArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestStructArrayArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestStructArrayArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestStructArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestStructArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestStructArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestNestedStructArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestNestedStructArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestNestedStructArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestListStructArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestListStructArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestListStructArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestListInt8UArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestListInt8UArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestListInt8UArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestNestedStructListArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestNestedStructListArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestNestedStructListArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestListNestedStructListArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestListNestedStructListArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestListNestedStructListArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestListInt8UReverseRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestListInt8UReverseRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestListInt8UReverseRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestEnumsRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestEnumsRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestEnumsRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestNullableOptionalRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestNullableOptionalRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestNullableOptionalRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestComplexNullableOptionalRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestComplexNullableOptionalRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestComplexNullableOptionalRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster SimpleStructEchoRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterSimpleStructEchoRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::SimpleStructEchoRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TimedInvokeRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTimedInvokeRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TimedInvokeRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestSimpleOptionalArgumentRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestSimpleOptionalArgumentRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestSimpleOptionalArgumentRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestEmitTestEventRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestEmitTestEventRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestEmitTestEventRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestEmitTestFabricScopedEventRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestEmitTestFabricScopedEventRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestEmitTestFabricScopedEventRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestBatchHelperRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestBatchHelperRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestBatchHelperRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestSecondBatchHelperRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestSecondBatchHelperRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestSecondBatchHelperRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster StringEchoRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterStringEchoRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::StringEchoRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster GlobalEchoRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterGlobalEchoRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::GlobalEchoRequest::DecodableType & commandData);
+/**
+ * @brief Unit Testing Cluster TestDifferentVendorMeiRequest Command callback (from client)
+ */
+bool emberAfUnitTestingClusterTestDifferentVendorMeiRequestCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::UnitTesting::Commands::TestDifferentVendorMeiRequest::DecodableType & commandData);
+/**
+ * @brief Fault Injection Cluster FailAtFault Command callback (from client)
+ */
+bool emberAfFaultInjectionClusterFailAtFaultCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::FaultInjection::Commands::FailAtFault::DecodableType & commandData);
+/**
+ * @brief Fault Injection Cluster FailRandomlyAtFault Command callback (from client)
+ */
+bool emberAfFaultInjectionClusterFailRandomlyAtFaultCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::FaultInjection::Commands::FailRandomlyAtFault::DecodableType & commandData);
+/**
+ * @brief Sample Manufacturer-Specific Cluster Ping Command callback (from client)
+ */
+bool emberAfSampleManufacturerSpecificClusterPingCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::DecodableType & commandData);
+/**
+ * @brief Sample Manufacturer-Specific Cluster AddArguments Command callback (from client)
+ */
+bool emberAfSampleManufacturerSpecificClusterAddArgumentsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::DecodableType & commandData);
+/**
+ * @brief Sample External manufacturer-specific Cluster Ping Command callback (from client)
+ */
+bool emberAfSampleExternalManufacturerSpecificClusterPingCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::SampleExternalManufacturerSpecific::Commands::Ping::DecodableType & commandData);
+/**
+ * @brief Sample External manufacturer-specific Cluster AddArguments Command callback (from client)
+ */
+bool emberAfSampleExternalManufacturerSpecificClusterAddArgumentsCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::SampleExternalManufacturerSpecific::Commands::AddArguments::DecodableType & commandData);
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h
new file mode 100644
index 00000000000000..5d991f47163b6a
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h
@@ -0,0 +1,3740 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-enums.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::AreaTypeTag val)
+{
+ using EnumType = Globals::AreaTypeTag;
+ switch (val)
+ {
+ case EnumType::kAisle:
+ case EnumType::kAttic:
+ case EnumType::kBackDoor:
+ case EnumType::kBackYard:
+ case EnumType::kBalcony:
+ case EnumType::kBallroom:
+ case EnumType::kBathroom:
+ case EnumType::kBedroom:
+ case EnumType::kBorder:
+ case EnumType::kBoxroom:
+ case EnumType::kBreakfastRoom:
+ case EnumType::kCarport:
+ case EnumType::kCellar:
+ case EnumType::kCloakroom:
+ case EnumType::kCloset:
+ case EnumType::kConservatory:
+ case EnumType::kCorridor:
+ case EnumType::kCraftRoom:
+ case EnumType::kCupboard:
+ case EnumType::kDeck:
+ case EnumType::kDen:
+ case EnumType::kDining:
+ case EnumType::kDrawingRoom:
+ case EnumType::kDressingRoom:
+ case EnumType::kDriveway:
+ case EnumType::kElevator:
+ case EnumType::kEnsuite:
+ case EnumType::kEntrance:
+ case EnumType::kEntryway:
+ case EnumType::kFamilyRoom:
+ case EnumType::kFoyer:
+ case EnumType::kFrontDoor:
+ case EnumType::kFrontYard:
+ case EnumType::kGameRoom:
+ case EnumType::kGarage:
+ case EnumType::kGarageDoor:
+ case EnumType::kGarden:
+ case EnumType::kGardenDoor:
+ case EnumType::kGuestBathroom:
+ case EnumType::kGuestBedroom:
+ case EnumType::kGuestRestroom:
+ case EnumType::kGuestRoom:
+ case EnumType::kGym:
+ case EnumType::kHallway:
+ case EnumType::kHearthRoom:
+ case EnumType::kKidsRoom:
+ case EnumType::kKidsBedroom:
+ case EnumType::kKitchen:
+ case EnumType::kLarder:
+ case EnumType::kLaundryRoom:
+ case EnumType::kLawn:
+ case EnumType::kLibrary:
+ case EnumType::kLivingRoom:
+ case EnumType::kLounge:
+ case EnumType::kMediaTvRoom:
+ case EnumType::kMudRoom:
+ case EnumType::kMusicRoom:
+ case EnumType::kNursery:
+ case EnumType::kOffice:
+ case EnumType::kOutdoorKitchen:
+ case EnumType::kOutside:
+ case EnumType::kPantry:
+ case EnumType::kParkingLot:
+ case EnumType::kParlor:
+ case EnumType::kPatio:
+ case EnumType::kPlayRoom:
+ case EnumType::kPoolRoom:
+ case EnumType::kPorch:
+ case EnumType::kPrimaryBathroom:
+ case EnumType::kPrimaryBedroom:
+ case EnumType::kRamp:
+ case EnumType::kReceptionRoom:
+ case EnumType::kRecreationRoom:
+ case EnumType::kRestroom:
+ case EnumType::kRoof:
+ case EnumType::kSauna:
+ case EnumType::kScullery:
+ case EnumType::kSewingRoom:
+ case EnumType::kShed:
+ case EnumType::kSideDoor:
+ case EnumType::kSideYard:
+ case EnumType::kSittingRoom:
+ case EnumType::kSnug:
+ case EnumType::kSpa:
+ case EnumType::kStaircase:
+ case EnumType::kSteamRoom:
+ case EnumType::kStorageRoom:
+ case EnumType::kStudio:
+ case EnumType::kStudy:
+ case EnumType::kSunRoom:
+ case EnumType::kSwimmingPool:
+ case EnumType::kTerrace:
+ case EnumType::kUtilityRoom:
+ case EnumType::kWard:
+ case EnumType::kWorkshop:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::AtomicRequestTypeEnum val)
+{
+ using EnumType = Globals::AtomicRequestTypeEnum;
+ switch (val)
+ {
+ case EnumType::kBeginWrite:
+ case EnumType::kCommitWrite:
+ case EnumType::kRollbackWrite:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::ChangeIndicationEnum val)
+{
+ using EnumType = detail::ChangeIndicationEnum;
+ switch (val)
+ {
+ case EnumType::kOk:
+ case EnumType::kWarning:
+ case EnumType::kCritical:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::DegradationDirectionEnum val)
+{
+ using EnumType = detail::DegradationDirectionEnum;
+ switch (val)
+ {
+ case EnumType::kUp:
+ case EnumType::kDown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::FloorSurfaceTag val)
+{
+ using EnumType = Globals::FloorSurfaceTag;
+ switch (val)
+ {
+ case EnumType::kCarpet:
+ case EnumType::kCeramic:
+ case EnumType::kConcrete:
+ case EnumType::kCork:
+ case EnumType::kDeepCarpet:
+ case EnumType::kDirt:
+ case EnumType::kEngineeredWood:
+ case EnumType::kGlass:
+ case EnumType::kGrass:
+ case EnumType::kHardwood:
+ case EnumType::kLaminate:
+ case EnumType::kLinoleum:
+ case EnumType::kMat:
+ case EnumType::kMetal:
+ case EnumType::kPlastic:
+ case EnumType::kPolishedConcrete:
+ case EnumType::kRubber:
+ case EnumType::kRug:
+ case EnumType::kSand:
+ case EnumType::kStone:
+ case EnumType::kTatami:
+ case EnumType::kTerrazzo:
+ case EnumType::kTile:
+ case EnumType::kVinyl:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::LandmarkTag val)
+{
+ using EnumType = Globals::LandmarkTag;
+ switch (val)
+ {
+ case EnumType::kAirConditioner:
+ case EnumType::kAirPurifier:
+ case EnumType::kBackDoor:
+ case EnumType::kBarStool:
+ case EnumType::kBathMat:
+ case EnumType::kBathtub:
+ case EnumType::kBed:
+ case EnumType::kBookshelf:
+ case EnumType::kChair:
+ case EnumType::kChristmasTree:
+ case EnumType::kCoatRack:
+ case EnumType::kCoffeeTable:
+ case EnumType::kCookingRange:
+ case EnumType::kCouch:
+ case EnumType::kCountertop:
+ case EnumType::kCradle:
+ case EnumType::kCrib:
+ case EnumType::kDesk:
+ case EnumType::kDiningTable:
+ case EnumType::kDishwasher:
+ case EnumType::kDoor:
+ case EnumType::kDresser:
+ case EnumType::kLaundryDryer:
+ case EnumType::kFan:
+ case EnumType::kFireplace:
+ case EnumType::kFreezer:
+ case EnumType::kFrontDoor:
+ case EnumType::kHighChair:
+ case EnumType::kKitchenIsland:
+ case EnumType::kLamp:
+ case EnumType::kLitterBox:
+ case EnumType::kMirror:
+ case EnumType::kNightstand:
+ case EnumType::kOven:
+ case EnumType::kPetBed:
+ case EnumType::kPetBowl:
+ case EnumType::kPetCrate:
+ case EnumType::kRefrigerator:
+ case EnumType::kScratchingPost:
+ case EnumType::kShoeRack:
+ case EnumType::kShower:
+ case EnumType::kSideDoor:
+ case EnumType::kSink:
+ case EnumType::kSofa:
+ case EnumType::kStove:
+ case EnumType::kTable:
+ case EnumType::kToilet:
+ case EnumType::kTrashCan:
+ case EnumType::kLaundryWasher:
+ case EnumType::kWindow:
+ case EnumType::kWineCooler:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::LevelValueEnum val)
+{
+ using EnumType = detail::LevelValueEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kLow:
+ case EnumType::kMedium:
+ case EnumType::kHigh:
+ case EnumType::kCritical:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::MeasurementMediumEnum val)
+{
+ using EnumType = detail::MeasurementMediumEnum;
+ switch (val)
+ {
+ case EnumType::kAir:
+ case EnumType::kWater:
+ case EnumType::kSoil:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::MeasurementTypeEnum val)
+{
+ using EnumType = detail::MeasurementTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kVoltage:
+ case EnumType::kActiveCurrent:
+ case EnumType::kReactiveCurrent:
+ case EnumType::kApparentCurrent:
+ case EnumType::kActivePower:
+ case EnumType::kReactivePower:
+ case EnumType::kApparentPower:
+ case EnumType::kRMSVoltage:
+ case EnumType::kRMSCurrent:
+ case EnumType::kRMSPower:
+ case EnumType::kFrequency:
+ case EnumType::kPowerFactor:
+ case EnumType::kNeutralCurrent:
+ case EnumType::kElectricalEnergy:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::MeasurementUnitEnum val)
+{
+ using EnumType = detail::MeasurementUnitEnum;
+ switch (val)
+ {
+ case EnumType::kPpm:
+ case EnumType::kPpb:
+ case EnumType::kPpt:
+ case EnumType::kMgm3:
+ case EnumType::kUgm3:
+ case EnumType::kNgm3:
+ case EnumType::kPm3:
+ case EnumType::kBqm3:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::PositionTag val)
+{
+ using EnumType = Globals::PositionTag;
+ switch (val)
+ {
+ case EnumType::kLeft:
+ case EnumType::kRight:
+ case EnumType::kTop:
+ case EnumType::kBottom:
+ case EnumType::kMiddle:
+ case EnumType::kRow:
+ case EnumType::kColumn:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::ProductIdentifierTypeEnum val)
+{
+ using EnumType = detail::ProductIdentifierTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUpc:
+ case EnumType::kGtin8:
+ case EnumType::kEan:
+ case EnumType::kGtin14:
+ case EnumType::kOem:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::RelativePositionTag val)
+{
+ using EnumType = Globals::RelativePositionTag;
+ switch (val)
+ {
+ case EnumType::kUnder:
+ case EnumType::kNextTo:
+ case EnumType::kAround:
+ case EnumType::kOn:
+ case EnumType::kAbove:
+ case EnumType::kFrontOf:
+ case EnumType::kBehind:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::StreamUsageEnum val)
+{
+ using EnumType = detail::StreamUsageEnum;
+ switch (val)
+ {
+ case EnumType::kInternal:
+ case EnumType::kRecording:
+ case EnumType::kAnalysis:
+ case EnumType::kLiveView:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::TestGlobalEnum val)
+{
+ using EnumType = Globals::TestGlobalEnum;
+ switch (val)
+ {
+ case EnumType::kSomeValue:
+ case EnumType::kSomeOtherValue:
+ case EnumType::kFinalValue:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Globals::ThreeLevelAutoEnum val)
+{
+ using EnumType = Globals::ThreeLevelAutoEnum;
+ switch (val)
+ {
+ case EnumType::kLow:
+ case EnumType::kMedium:
+ case EnumType::kHigh:
+ case EnumType::kAutomatic:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(detail::WebRTCEndReasonEnum val)
+{
+ using EnumType = detail::WebRTCEndReasonEnum;
+ switch (val)
+ {
+ case EnumType::kIceFailed:
+ case EnumType::kIceTimeout:
+ case EnumType::kUserHangup:
+ case EnumType::kUserBusy:
+ case EnumType::kReplaced:
+ case EnumType::kNoUserMedia:
+ case EnumType::kInviteTimeout:
+ case EnumType::kAnsweredElsewhere:
+ case EnumType::kOutOfResources:
+ case EnumType::kMediaTimeout:
+ case EnumType::kLowPower:
+ case EnumType::kUnknownReason:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::EffectIdentifierEnum val)
+{
+ using EnumType = Identify::EffectIdentifierEnum;
+ switch (val)
+ {
+ case EnumType::kBlink:
+ case EnumType::kBreathe:
+ case EnumType::kOkay:
+ case EnumType::kChannelChange:
+ case EnumType::kFinishEffect:
+ case EnumType::kStopEffect:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::EffectVariantEnum val)
+{
+ using EnumType = Identify::EffectVariantEnum;
+ switch (val)
+ {
+ case EnumType::kDefault:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyTypeEnum val)
+{
+ using EnumType = Identify::IdentifyTypeEnum;
+ switch (val)
+ {
+ case EnumType::kNone:
+ case EnumType::kLightOutput:
+ case EnumType::kVisibleIndicator:
+ case EnumType::kAudibleBeep:
+ case EnumType::kDisplay:
+ case EnumType::kActuator:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::DelayedAllOffEffectVariantEnum val)
+{
+ using EnumType = OnOff::DelayedAllOffEffectVariantEnum;
+ switch (val)
+ {
+ case EnumType::kDelayedOffFastFade:
+ case EnumType::kNoFade:
+ case EnumType::kDelayedOffSlowFade:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::DyingLightEffectVariantEnum val)
+{
+ using EnumType = OnOff::DyingLightEffectVariantEnum;
+ switch (val)
+ {
+ case EnumType::kDyingLightFadeOff:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::EffectIdentifierEnum val)
+{
+ using EnumType = OnOff::EffectIdentifierEnum;
+ switch (val)
+ {
+ case EnumType::kDelayedAllOff:
+ case EnumType::kDyingLight:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::StartUpOnOffEnum val)
+{
+ using EnumType = OnOff::StartUpOnOffEnum;
+ switch (val)
+ {
+ case EnumType::kOff:
+ case EnumType::kOn:
+ case EnumType::kToggle:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(LevelControl::MoveModeEnum val)
+{
+ using EnumType = LevelControl::MoveModeEnum;
+ switch (val)
+ {
+ case EnumType::kUp:
+ case EnumType::kDown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(LevelControl::StepModeEnum val)
+{
+ using EnumType = LevelControl::StepModeEnum;
+ switch (val)
+ {
+ case EnumType::kUp:
+ case EnumType::kDown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::AccessControlEntryAuthModeEnum val)
+{
+ using EnumType = AccessControl::AccessControlEntryAuthModeEnum;
+ switch (val)
+ {
+ case EnumType::kPase:
+ case EnumType::kCase:
+ case EnumType::kGroup:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::AccessControlEntryPrivilegeEnum val)
+{
+ using EnumType = AccessControl::AccessControlEntryPrivilegeEnum;
+ switch (val)
+ {
+ case EnumType::kView:
+ case EnumType::kProxyView:
+ case EnumType::kOperate:
+ case EnumType::kManage:
+ case EnumType::kAdminister:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::AccessRestrictionTypeEnum val)
+{
+ using EnumType = AccessControl::AccessRestrictionTypeEnum;
+ switch (val)
+ {
+ case EnumType::kAttributeAccessForbidden:
+ case EnumType::kAttributeWriteForbidden:
+ case EnumType::kCommandForbidden:
+ case EnumType::kEventForbidden:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::ChangeTypeEnum val)
+{
+ using EnumType = AccessControl::ChangeTypeEnum;
+ switch (val)
+ {
+ case EnumType::kChanged:
+ case EnumType::kAdded:
+ case EnumType::kRemoved:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::ActionErrorEnum val)
+{
+ using EnumType = Actions::ActionErrorEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kInterrupted:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::ActionStateEnum val)
+{
+ using EnumType = Actions::ActionStateEnum;
+ switch (val)
+ {
+ case EnumType::kInactive:
+ case EnumType::kActive:
+ case EnumType::kPaused:
+ case EnumType::kDisabled:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::ActionTypeEnum val)
+{
+ using EnumType = Actions::ActionTypeEnum;
+ switch (val)
+ {
+ case EnumType::kOther:
+ case EnumType::kScene:
+ case EnumType::kSequence:
+ case EnumType::kAutomation:
+ case EnumType::kException:
+ case EnumType::kNotification:
+ case EnumType::kAlarm:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::EndpointListTypeEnum val)
+{
+ using EnumType = Actions::EndpointListTypeEnum;
+ switch (val)
+ {
+ case EnumType::kOther:
+ case EnumType::kRoom:
+ case EnumType::kZone:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(BasicInformation::ColorEnum val)
+{
+ using EnumType = BasicInformation::ColorEnum;
+ switch (val)
+ {
+ case EnumType::kBlack:
+ case EnumType::kNavy:
+ case EnumType::kGreen:
+ case EnumType::kTeal:
+ case EnumType::kMaroon:
+ case EnumType::kPurple:
+ case EnumType::kOlive:
+ case EnumType::kGray:
+ case EnumType::kBlue:
+ case EnumType::kLime:
+ case EnumType::kAqua:
+ case EnumType::kRed:
+ case EnumType::kFuchsia:
+ case EnumType::kYellow:
+ case EnumType::kWhite:
+ case EnumType::kNickel:
+ case EnumType::kChrome:
+ case EnumType::kBrass:
+ case EnumType::kCopper:
+ case EnumType::kSilver:
+ case EnumType::kGold:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(BasicInformation::ProductFinishEnum val)
+{
+ using EnumType = BasicInformation::ProductFinishEnum;
+ switch (val)
+ {
+ case EnumType::kOther:
+ case EnumType::kMatte:
+ case EnumType::kSatin:
+ case EnumType::kPolished:
+ case EnumType::kRugged:
+ case EnumType::kFabric:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::ApplyUpdateActionEnum val)
+{
+ using EnumType = OtaSoftwareUpdateProvider::ApplyUpdateActionEnum;
+ switch (val)
+ {
+ case EnumType::kProceed:
+ case EnumType::kAwaitNextAction:
+ case EnumType::kDiscontinue:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::DownloadProtocolEnum val)
+{
+ using EnumType = OtaSoftwareUpdateProvider::DownloadProtocolEnum;
+ switch (val)
+ {
+ case EnumType::kBDXSynchronous:
+ case EnumType::kBDXAsynchronous:
+ case EnumType::kHttps:
+ case EnumType::kVendorSpecific:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::StatusEnum val)
+{
+ using EnumType = OtaSoftwareUpdateProvider::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kUpdateAvailable:
+ case EnumType::kBusy:
+ case EnumType::kNotAvailable:
+ case EnumType::kDownloadProtocolNotSupported:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::AnnouncementReasonEnum val)
+{
+ using EnumType = OtaSoftwareUpdateRequestor::AnnouncementReasonEnum;
+ switch (val)
+ {
+ case EnumType::kSimpleAnnouncement:
+ case EnumType::kUpdateAvailable:
+ case EnumType::kUrgentUpdateAvailable:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::ChangeReasonEnum val)
+{
+ using EnumType = OtaSoftwareUpdateRequestor::ChangeReasonEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kSuccess:
+ case EnumType::kFailure:
+ case EnumType::kTimeOut:
+ case EnumType::kDelayByProvider:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::UpdateStateEnum val)
+{
+ using EnumType = OtaSoftwareUpdateRequestor::UpdateStateEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kIdle:
+ case EnumType::kQuerying:
+ case EnumType::kDelayedOnQuery:
+ case EnumType::kDownloading:
+ case EnumType::kApplying:
+ case EnumType::kDelayedOnApply:
+ case EnumType::kRollingBack:
+ case EnumType::kDelayedOnUserConsent:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(TimeFormatLocalization::CalendarTypeEnum val)
+{
+ using EnumType = TimeFormatLocalization::CalendarTypeEnum;
+ switch (val)
+ {
+ case EnumType::kBuddhist:
+ case EnumType::kChinese:
+ case EnumType::kCoptic:
+ case EnumType::kEthiopian:
+ case EnumType::kGregorian:
+ case EnumType::kHebrew:
+ case EnumType::kIndian:
+ case EnumType::kIslamic:
+ case EnumType::kJapanese:
+ case EnumType::kKorean:
+ case EnumType::kPersian:
+ case EnumType::kTaiwanese:
+ case EnumType::kUseActiveLocale:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(TimeFormatLocalization::HourFormatEnum val)
+{
+ using EnumType = TimeFormatLocalization::HourFormatEnum;
+ switch (val)
+ {
+ case EnumType::k12hr:
+ case EnumType::k24hr:
+ case EnumType::kUseActiveLocale:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(UnitLocalization::TempUnitEnum val)
+{
+ using EnumType = UnitLocalization::TempUnitEnum;
+ switch (val)
+ {
+ case EnumType::kFahrenheit:
+ case EnumType::kCelsius:
+ case EnumType::kKelvin:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatApprovedChemistryEnum val)
+{
+ using EnumType = PowerSource::BatApprovedChemistryEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kAlkaline:
+ case EnumType::kLithiumCarbonFluoride:
+ case EnumType::kLithiumChromiumOxide:
+ case EnumType::kLithiumCopperOxide:
+ case EnumType::kLithiumIronDisulfide:
+ case EnumType::kLithiumManganeseDioxide:
+ case EnumType::kLithiumThionylChloride:
+ case EnumType::kMagnesium:
+ case EnumType::kMercuryOxide:
+ case EnumType::kNickelOxyhydride:
+ case EnumType::kSilverOxide:
+ case EnumType::kZincAir:
+ case EnumType::kZincCarbon:
+ case EnumType::kZincChloride:
+ case EnumType::kZincManganeseDioxide:
+ case EnumType::kLeadAcid:
+ case EnumType::kLithiumCobaltOxide:
+ case EnumType::kLithiumIon:
+ case EnumType::kLithiumIonPolymer:
+ case EnumType::kLithiumIronPhosphate:
+ case EnumType::kLithiumSulfur:
+ case EnumType::kLithiumTitanate:
+ case EnumType::kNickelCadmium:
+ case EnumType::kNickelHydrogen:
+ case EnumType::kNickelIron:
+ case EnumType::kNickelMetalHydride:
+ case EnumType::kNickelZinc:
+ case EnumType::kSilverZinc:
+ case EnumType::kSodiumIon:
+ case EnumType::kSodiumSulfur:
+ case EnumType::kZincBromide:
+ case EnumType::kZincCerium:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeFaultEnum val)
+{
+ using EnumType = PowerSource::BatChargeFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kAmbientTooHot:
+ case EnumType::kAmbientTooCold:
+ case EnumType::kBatteryTooHot:
+ case EnumType::kBatteryTooCold:
+ case EnumType::kBatteryAbsent:
+ case EnumType::kBatteryOverVoltage:
+ case EnumType::kBatteryUnderVoltage:
+ case EnumType::kChargerOverVoltage:
+ case EnumType::kChargerUnderVoltage:
+ case EnumType::kSafetyTimeout:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeLevelEnum val)
+{
+ using EnumType = PowerSource::BatChargeLevelEnum;
+ switch (val)
+ {
+ case EnumType::kOk:
+ case EnumType::kWarning:
+ case EnumType::kCritical:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeStateEnum val)
+{
+ using EnumType = PowerSource::BatChargeStateEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kIsCharging:
+ case EnumType::kIsAtFullCharge:
+ case EnumType::kIsNotCharging:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatCommonDesignationEnum val)
+{
+ using EnumType = PowerSource::BatCommonDesignationEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kAaa:
+ case EnumType::kAa:
+ case EnumType::kC:
+ case EnumType::kD:
+ case EnumType::k4v5:
+ case EnumType::k6v0:
+ case EnumType::k9v0:
+ case EnumType::k12aa:
+ case EnumType::kAaaa:
+ case EnumType::kA:
+ case EnumType::kB:
+ case EnumType::kF:
+ case EnumType::kN:
+ case EnumType::kNo6:
+ case EnumType::kSubC:
+ case EnumType::kA23:
+ case EnumType::kA27:
+ case EnumType::kBa5800:
+ case EnumType::kDuplex:
+ case EnumType::k4sr44:
+ case EnumType::k523:
+ case EnumType::k531:
+ case EnumType::k15v0:
+ case EnumType::k22v5:
+ case EnumType::k30v0:
+ case EnumType::k45v0:
+ case EnumType::k67v5:
+ case EnumType::kJ:
+ case EnumType::kCr123a:
+ case EnumType::kCr2:
+ case EnumType::k2cr5:
+ case EnumType::kCrP2:
+ case EnumType::kCrV3:
+ case EnumType::kSr41:
+ case EnumType::kSr43:
+ case EnumType::kSr44:
+ case EnumType::kSr45:
+ case EnumType::kSr48:
+ case EnumType::kSr54:
+ case EnumType::kSr55:
+ case EnumType::kSr57:
+ case EnumType::kSr58:
+ case EnumType::kSr59:
+ case EnumType::kSr60:
+ case EnumType::kSr63:
+ case EnumType::kSr64:
+ case EnumType::kSr65:
+ case EnumType::kSr66:
+ case EnumType::kSr67:
+ case EnumType::kSr68:
+ case EnumType::kSr69:
+ case EnumType::kSr516:
+ case EnumType::kSr731:
+ case EnumType::kSr712:
+ case EnumType::kLr932:
+ case EnumType::kA5:
+ case EnumType::kA10:
+ case EnumType::kA13:
+ case EnumType::kA312:
+ case EnumType::kA675:
+ case EnumType::kAc41e:
+ case EnumType::k10180:
+ case EnumType::k10280:
+ case EnumType::k10440:
+ case EnumType::k14250:
+ case EnumType::k14430:
+ case EnumType::k14500:
+ case EnumType::k14650:
+ case EnumType::k15270:
+ case EnumType::k16340:
+ case EnumType::kRcr123a:
+ case EnumType::k17500:
+ case EnumType::k17670:
+ case EnumType::k18350:
+ case EnumType::k18500:
+ case EnumType::k18650:
+ case EnumType::k19670:
+ case EnumType::k25500:
+ case EnumType::k26650:
+ case EnumType::k32600:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatFaultEnum val)
+{
+ using EnumType = PowerSource::BatFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kOverTemp:
+ case EnumType::kUnderTemp:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatReplaceabilityEnum val)
+{
+ using EnumType = PowerSource::BatReplaceabilityEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kNotReplaceable:
+ case EnumType::kUserReplaceable:
+ case EnumType::kFactoryReplaceable:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::PowerSourceStatusEnum val)
+{
+ using EnumType = PowerSource::PowerSourceStatusEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kActive:
+ case EnumType::kStandby:
+ case EnumType::kUnavailable:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::WiredCurrentTypeEnum val)
+{
+ using EnumType = PowerSource::WiredCurrentTypeEnum;
+ switch (val)
+ {
+ case EnumType::kAc:
+ case EnumType::kDc:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::WiredFaultEnum val)
+{
+ using EnumType = PowerSource::WiredFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kOverVoltage:
+ case EnumType::kUnderVoltage:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralCommissioning::CommissioningErrorEnum val)
+{
+ using EnumType = GeneralCommissioning::CommissioningErrorEnum;
+ switch (val)
+ {
+ case EnumType::kOk:
+ case EnumType::kValueOutsideRange:
+ case EnumType::kInvalidAuthentication:
+ case EnumType::kNoFailSafe:
+ case EnumType::kBusyWithOtherAdmin:
+ case EnumType::kRequiredTCNotAccepted:
+ case EnumType::kTCAcknowledgementsNotReceived:
+ case EnumType::kTCMinVersionNotMet:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralCommissioning::RegulatoryLocationTypeEnum val)
+{
+ using EnumType = GeneralCommissioning::RegulatoryLocationTypeEnum;
+ switch (val)
+ {
+ case EnumType::kIndoor:
+ case EnumType::kOutdoor:
+ case EnumType::kIndoorOutdoor:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(NetworkCommissioning::NetworkCommissioningStatusEnum val)
+{
+ using EnumType = NetworkCommissioning::NetworkCommissioningStatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kOutOfRange:
+ case EnumType::kBoundsExceeded:
+ case EnumType::kNetworkIDNotFound:
+ case EnumType::kDuplicateNetworkID:
+ case EnumType::kNetworkNotFound:
+ case EnumType::kRegulatoryError:
+ case EnumType::kAuthFailure:
+ case EnumType::kUnsupportedSecurity:
+ case EnumType::kOtherConnectionFailure:
+ case EnumType::kIPV6Failed:
+ case EnumType::kIPBindFailed:
+ case EnumType::kUnknownError:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(NetworkCommissioning::WiFiBandEnum val)
+{
+ using EnumType = NetworkCommissioning::WiFiBandEnum;
+ switch (val)
+ {
+ case EnumType::k2g4:
+ case EnumType::k3g65:
+ case EnumType::k5g:
+ case EnumType::k6g:
+ case EnumType::k60g:
+ case EnumType::k1g:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::IntentEnum val)
+{
+ using EnumType = DiagnosticLogs::IntentEnum;
+ switch (val)
+ {
+ case EnumType::kEndUserSupport:
+ case EnumType::kNetworkDiag:
+ case EnumType::kCrashLogs:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::StatusEnum val)
+{
+ using EnumType = DiagnosticLogs::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kExhausted:
+ case EnumType::kNoLogs:
+ case EnumType::kBusy:
+ case EnumType::kDenied:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::TransferProtocolEnum val)
+{
+ using EnumType = DiagnosticLogs::TransferProtocolEnum;
+ switch (val)
+ {
+ case EnumType::kResponsePayload:
+ case EnumType::kBdx:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::BootReasonEnum val)
+{
+ using EnumType = GeneralDiagnostics::BootReasonEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kPowerOnReboot:
+ case EnumType::kBrownOutReset:
+ case EnumType::kSoftwareWatchdogReset:
+ case EnumType::kHardwareWatchdogReset:
+ case EnumType::kSoftwareUpdateCompleted:
+ case EnumType::kSoftwareReset:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::HardwareFaultEnum val)
+{
+ using EnumType = GeneralDiagnostics::HardwareFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kRadio:
+ case EnumType::kSensor:
+ case EnumType::kResettableOverTemp:
+ case EnumType::kNonResettableOverTemp:
+ case EnumType::kPowerSource:
+ case EnumType::kVisualDisplayFault:
+ case EnumType::kAudioOutputFault:
+ case EnumType::kUserInterfaceFault:
+ case EnumType::kNonVolatileMemoryError:
+ case EnumType::kTamperDetected:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::InterfaceTypeEnum val)
+{
+ using EnumType = GeneralDiagnostics::InterfaceTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kWiFi:
+ case EnumType::kEthernet:
+ case EnumType::kCellular:
+ case EnumType::kThread:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::NetworkFaultEnum val)
+{
+ using EnumType = GeneralDiagnostics::NetworkFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kHardwareFailure:
+ case EnumType::kNetworkJammed:
+ case EnumType::kConnectionFailed:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::RadioFaultEnum val)
+{
+ using EnumType = GeneralDiagnostics::RadioFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kWiFiFault:
+ case EnumType::kCellularFault:
+ case EnumType::kThreadFault:
+ case EnumType::kNFCFault:
+ case EnumType::kBLEFault:
+ case EnumType::kEthernetFault:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::ConnectionStatusEnum val)
+{
+ using EnumType = ThreadNetworkDiagnostics::ConnectionStatusEnum;
+ switch (val)
+ {
+ case EnumType::kConnected:
+ case EnumType::kNotConnected:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::NetworkFaultEnum val)
+{
+ using EnumType = ThreadNetworkDiagnostics::NetworkFaultEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kLinkDown:
+ case EnumType::kHardwareFailure:
+ case EnumType::kNetworkJammed:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::RoutingRoleEnum val)
+{
+ using EnumType = ThreadNetworkDiagnostics::RoutingRoleEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kUnassigned:
+ case EnumType::kSleepyEndDevice:
+ case EnumType::kEndDevice:
+ case EnumType::kReed:
+ case EnumType::kRouter:
+ case EnumType::kLeader:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::AssociationFailureCauseEnum val)
+{
+ using EnumType = WiFiNetworkDiagnostics::AssociationFailureCauseEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kAssociationFailed:
+ case EnumType::kAuthenticationFailed:
+ case EnumType::kSsidNotFound:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::ConnectionStatusEnum val)
+{
+ using EnumType = WiFiNetworkDiagnostics::ConnectionStatusEnum;
+ switch (val)
+ {
+ case EnumType::kConnected:
+ case EnumType::kNotConnected:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::SecurityTypeEnum val)
+{
+ using EnumType = WiFiNetworkDiagnostics::SecurityTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kNone:
+ case EnumType::kWep:
+ case EnumType::kWpa:
+ case EnumType::kWpa2:
+ case EnumType::kWpa3:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::WiFiVersionEnum val)
+{
+ using EnumType = WiFiNetworkDiagnostics::WiFiVersionEnum;
+ switch (val)
+ {
+ case EnumType::kA:
+ case EnumType::kB:
+ case EnumType::kG:
+ case EnumType::kN:
+ case EnumType::kAc:
+ case EnumType::kAx:
+ case EnumType::kAh:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(EthernetNetworkDiagnostics::PHYRateEnum val)
+{
+ using EnumType = EthernetNetworkDiagnostics::PHYRateEnum;
+ switch (val)
+ {
+ case EnumType::kRate10M:
+ case EnumType::kRate100M:
+ case EnumType::kRate1G:
+ case EnumType::kRate25g:
+ case EnumType::kRate5G:
+ case EnumType::kRate10G:
+ case EnumType::kRate40G:
+ case EnumType::kRate100G:
+ case EnumType::kRate200G:
+ case EnumType::kRate400G:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::GranularityEnum val)
+{
+ using EnumType = TimeSynchronization::GranularityEnum;
+ switch (val)
+ {
+ case EnumType::kNoTimeGranularity:
+ case EnumType::kMinutesGranularity:
+ case EnumType::kSecondsGranularity:
+ case EnumType::kMillisecondsGranularity:
+ case EnumType::kMicrosecondsGranularity:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::StatusCode val)
+{
+ using EnumType = TimeSynchronization::StatusCode;
+ switch (val)
+ {
+ case EnumType::kTimeNotAccepted:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::TimeSourceEnum val)
+{
+ using EnumType = TimeSynchronization::TimeSourceEnum;
+ switch (val)
+ {
+ case EnumType::kNone:
+ case EnumType::kUnknown:
+ case EnumType::kAdmin:
+ case EnumType::kNodeTimeCluster:
+ case EnumType::kNonMatterSNTP:
+ case EnumType::kNonMatterNTP:
+ case EnumType::kMatterSNTP:
+ case EnumType::kMatterNTP:
+ case EnumType::kMixedNTP:
+ case EnumType::kNonMatterSNTPNTS:
+ case EnumType::kNonMatterNTPNTS:
+ case EnumType::kMatterSNTPNTS:
+ case EnumType::kMatterNTPNTS:
+ case EnumType::kMixedNTPNTS:
+ case EnumType::kCloudSource:
+ case EnumType::kPtp:
+ case EnumType::kGnss:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::TimeZoneDatabaseEnum val)
+{
+ using EnumType = TimeSynchronization::TimeZoneDatabaseEnum;
+ switch (val)
+ {
+ case EnumType::kFull:
+ case EnumType::kPartial:
+ case EnumType::kNone:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedDeviceBasicInformation::ColorEnum val)
+{
+ using EnumType = BridgedDeviceBasicInformation::ColorEnum;
+ switch (val)
+ {
+ case EnumType::kBlack:
+ case EnumType::kNavy:
+ case EnumType::kGreen:
+ case EnumType::kTeal:
+ case EnumType::kMaroon:
+ case EnumType::kPurple:
+ case EnumType::kOlive:
+ case EnumType::kGray:
+ case EnumType::kBlue:
+ case EnumType::kLime:
+ case EnumType::kAqua:
+ case EnumType::kRed:
+ case EnumType::kFuchsia:
+ case EnumType::kYellow:
+ case EnumType::kWhite:
+ case EnumType::kNickel:
+ case EnumType::kChrome:
+ case EnumType::kBrass:
+ case EnumType::kCopper:
+ case EnumType::kSilver:
+ case EnumType::kGold:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedDeviceBasicInformation::ProductFinishEnum val)
+{
+ using EnumType = BridgedDeviceBasicInformation::ProductFinishEnum;
+ switch (val)
+ {
+ case EnumType::kOther:
+ case EnumType::kMatte:
+ case EnumType::kSatin:
+ case EnumType::kPolished:
+ case EnumType::kRugged:
+ case EnumType::kFabric:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(AdministratorCommissioning::CommissioningWindowStatusEnum val)
+{
+ using EnumType = AdministratorCommissioning::CommissioningWindowStatusEnum;
+ switch (val)
+ {
+ case EnumType::kWindowNotOpen:
+ case EnumType::kEnhancedWindowOpen:
+ case EnumType::kBasicWindowOpen:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(AdministratorCommissioning::StatusCode val)
+{
+ using EnumType = AdministratorCommissioning::StatusCode;
+ switch (val)
+ {
+ case EnumType::kBusy:
+ case EnumType::kPAKEParameterError:
+ case EnumType::kWindowNotOpen:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalCredentials::CertificateChainTypeEnum val)
+{
+ using EnumType = OperationalCredentials::CertificateChainTypeEnum;
+ switch (val)
+ {
+ case EnumType::kDACCertificate:
+ case EnumType::kPAICertificate:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalCredentials::NodeOperationalCertStatusEnum val)
+{
+ using EnumType = OperationalCredentials::NodeOperationalCertStatusEnum;
+ switch (val)
+ {
+ case EnumType::kOk:
+ case EnumType::kInvalidPublicKey:
+ case EnumType::kInvalidNodeOpId:
+ case EnumType::kInvalidNOC:
+ case EnumType::kMissingCsr:
+ case EnumType::kTableFull:
+ case EnumType::kInvalidAdminSubject:
+ case EnumType::kFabricConflict:
+ case EnumType::kLabelConflict:
+ case EnumType::kInvalidFabricIndex:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(GroupKeyManagement::GroupKeySecurityPolicyEnum val)
+{
+ using EnumType = GroupKeyManagement::GroupKeySecurityPolicyEnum;
+ switch (val)
+ {
+ case EnumType::kTrustFirst:
+ case EnumType::kCacheAndSync:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(IcdManagement::ClientTypeEnum val)
+{
+ using EnumType = IcdManagement::ClientTypeEnum;
+ switch (val)
+ {
+ case EnumType::kPermanent:
+ case EnumType::kEphemeral:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(IcdManagement::OperatingModeEnum val)
+{
+ using EnumType = IcdManagement::OperatingModeEnum;
+ switch (val)
+ {
+ case EnumType::kSit:
+ case EnumType::kLit:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Timer::TimerStatusEnum val)
+{
+ using EnumType = Timer::TimerStatusEnum;
+ switch (val)
+ {
+ case EnumType::kRunning:
+ case EnumType::kPaused:
+ case EnumType::kExpired:
+ case EnumType::kReady:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OvenCavityOperationalState::ErrorStateEnum val)
+{
+ using EnumType = OvenCavityOperationalState::ErrorStateEnum;
+ switch (val)
+ {
+ case EnumType::kNoError:
+ case EnumType::kUnableToStartOrResume:
+ case EnumType::kUnableToCompleteOperation:
+ case EnumType::kCommandInvalidInState:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OvenCavityOperationalState::OperationalStateEnum val)
+{
+ using EnumType = OvenCavityOperationalState::OperationalStateEnum;
+ switch (val)
+ {
+ case EnumType::kStopped:
+ case EnumType::kRunning:
+ case EnumType::kPaused:
+ case EnumType::kError:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OvenMode::ModeTag val)
+{
+ using EnumType = OvenMode::ModeTag;
+ switch (val)
+ {
+ case EnumType::kAuto:
+ case EnumType::kQuick:
+ case EnumType::kQuiet:
+ case EnumType::kLowNoise:
+ case EnumType::kLowEnergy:
+ case EnumType::kVacation:
+ case EnumType::kMin:
+ case EnumType::kMax:
+ case EnumType::kNight:
+ case EnumType::kDay:
+ case EnumType::kBake:
+ case EnumType::kConvection:
+ case EnumType::kGrill:
+ case EnumType::kRoast:
+ case EnumType::kClean:
+ case EnumType::kConvectionBake:
+ case EnumType::kConvectionRoast:
+ case EnumType::kWarming:
+ case EnumType::kProofing:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(LaundryDryerControls::DrynessLevelEnum val)
+{
+ using EnumType = LaundryDryerControls::DrynessLevelEnum;
+ switch (val)
+ {
+ case EnumType::kLow:
+ case EnumType::kNormal:
+ case EnumType::kExtra:
+ case EnumType::kMax:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(LaundryWasherControls::NumberOfRinsesEnum val)
+{
+ using EnumType = LaundryWasherControls::NumberOfRinsesEnum;
+ switch (val)
+ {
+ case EnumType::kNone:
+ case EnumType::kNormal:
+ case EnumType::kExtra:
+ case EnumType::kMax:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(AirQuality::AirQualityEnum val)
+{
+ using EnumType = AirQuality::AirQualityEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kGood:
+ case EnumType::kFair:
+ case EnumType::kModerate:
+ case EnumType::kPoor:
+ case EnumType::kVeryPoor:
+ case EnumType::kExtremelyPoor:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(SmokeCoAlarm::AlarmStateEnum val)
+{
+ using EnumType = SmokeCoAlarm::AlarmStateEnum;
+ switch (val)
+ {
+ case EnumType::kNormal:
+ case EnumType::kWarning:
+ case EnumType::kCritical:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(SmokeCoAlarm::ContaminationStateEnum val)
+{
+ using EnumType = SmokeCoAlarm::ContaminationStateEnum;
+ switch (val)
+ {
+ case EnumType::kNormal:
+ case EnumType::kLow:
+ case EnumType::kWarning:
+ case EnumType::kCritical:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(SmokeCoAlarm::EndOfServiceEnum val)
+{
+ using EnumType = SmokeCoAlarm::EndOfServiceEnum;
+ switch (val)
+ {
+ case EnumType::kNormal:
+ case EnumType::kExpired:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(SmokeCoAlarm::ExpressedStateEnum val)
+{
+ using EnumType = SmokeCoAlarm::ExpressedStateEnum;
+ switch (val)
+ {
+ case EnumType::kNormal:
+ case EnumType::kSmokeAlarm:
+ case EnumType::kCOAlarm:
+ case EnumType::kBatteryAlert:
+ case EnumType::kTesting:
+ case EnumType::kHardwareFault:
+ case EnumType::kEndOfService:
+ case EnumType::kInterconnectSmoke:
+ case EnumType::kInterconnectCO:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(SmokeCoAlarm::MuteStateEnum val)
+{
+ using EnumType = SmokeCoAlarm::MuteStateEnum;
+ switch (val)
+ {
+ case EnumType::kNotMuted:
+ case EnumType::kMuted:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(SmokeCoAlarm::SensitivityEnum val)
+{
+ using EnumType = SmokeCoAlarm::SensitivityEnum;
+ switch (val)
+ {
+ case EnumType::kHigh:
+ case EnumType::kStandard:
+ case EnumType::kLow:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(MicrowaveOvenMode::ModeTag val)
+{
+ using EnumType = MicrowaveOvenMode::ModeTag;
+ switch (val)
+ {
+ case EnumType::kAuto:
+ case EnumType::kQuick:
+ case EnumType::kQuiet:
+ case EnumType::kLowNoise:
+ case EnumType::kLowEnergy:
+ case EnumType::kVacation:
+ case EnumType::kMin:
+ case EnumType::kMax:
+ case EnumType::kNight:
+ case EnumType::kDay:
+ case EnumType::kNormal:
+ case EnumType::kDefrost:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalState::ErrorStateEnum val)
+{
+ using EnumType = OperationalState::ErrorStateEnum;
+ switch (val)
+ {
+ case EnumType::kNoError:
+ case EnumType::kUnableToStartOrResume:
+ case EnumType::kUnableToCompleteOperation:
+ case EnumType::kCommandInvalidInState:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalState::OperationalStateEnum val)
+{
+ using EnumType = OperationalState::OperationalStateEnum;
+ switch (val)
+ {
+ case EnumType::kStopped:
+ case EnumType::kRunning:
+ case EnumType::kPaused:
+ case EnumType::kError:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ValveConfigurationAndControl::StatusCodeEnum val)
+{
+ using EnumType = ValveConfigurationAndControl::StatusCodeEnum;
+ switch (val)
+ {
+ case EnumType::kFailureDueToFault:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ValveConfigurationAndControl::ValveStateEnum val)
+{
+ using EnumType = ValveConfigurationAndControl::ValveStateEnum;
+ switch (val)
+ {
+ case EnumType::kClosed:
+ case EnumType::kOpen:
+ case EnumType::kTransitioning:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ElectricalPowerMeasurement::PowerModeEnum val)
+{
+ using EnumType = ElectricalPowerMeasurement::PowerModeEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kDc:
+ case EnumType::kAc:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(WaterHeaterManagement::BoostStateEnum val)
+{
+ using EnumType = WaterHeaterManagement::BoostStateEnum;
+ switch (val)
+ {
+ case EnumType::kInactive:
+ case EnumType::kActive:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(DemandResponseLoadControl::CriticalityLevelEnum val)
+{
+ using EnumType = DemandResponseLoadControl::CriticalityLevelEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kGreen:
+ case EnumType::kLevel1:
+ case EnumType::kLevel2:
+ case EnumType::kLevel3:
+ case EnumType::kLevel4:
+ case EnumType::kLevel5:
+ case EnumType::kEmergency:
+ case EnumType::kPlannedOutage:
+ case EnumType::kServiceDisconnect:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DemandResponseLoadControl::HeatingSourceEnum val)
+{
+ using EnumType = DemandResponseLoadControl::HeatingSourceEnum;
+ switch (val)
+ {
+ case EnumType::kAny:
+ case EnumType::kElectric:
+ case EnumType::kNonElectric:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DemandResponseLoadControl::LoadControlEventChangeSourceEnum val)
+{
+ using EnumType = DemandResponseLoadControl::LoadControlEventChangeSourceEnum;
+ switch (val)
+ {
+ case EnumType::kAutomatic:
+ case EnumType::kUserAction:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DemandResponseLoadControl::LoadControlEventStatusEnum val)
+{
+ using EnumType = DemandResponseLoadControl::LoadControlEventStatusEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kReceived:
+ case EnumType::kInProgress:
+ case EnumType::kCompleted:
+ case EnumType::kOptedOut:
+ case EnumType::kOptedIn:
+ case EnumType::kCanceled:
+ case EnumType::kSuperseded:
+ case EnumType::kPartialOptedOut:
+ case EnumType::kPartialOptedIn:
+ case EnumType::kNoParticipation:
+ case EnumType::kUnavailable:
+ case EnumType::kFailed:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Messages::FutureMessagePreferenceEnum val)
+{
+ using EnumType = Messages::FutureMessagePreferenceEnum;
+ switch (val)
+ {
+ case EnumType::kAllowed:
+ case EnumType::kIncreased:
+ case EnumType::kReduced:
+ case EnumType::kDisallowed:
+ case EnumType::kBanned:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Messages::MessagePriorityEnum val)
+{
+ using EnumType = Messages::MessagePriorityEnum;
+ switch (val)
+ {
+ case EnumType::kLow:
+ case EnumType::kMedium:
+ case EnumType::kHigh:
+ case EnumType::kCritical:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::AdjustmentCauseEnum val)
+{
+ using EnumType = DeviceEnergyManagement::AdjustmentCauseEnum;
+ switch (val)
+ {
+ case EnumType::kLocalOptimization:
+ case EnumType::kGridOptimization:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::CauseEnum val)
+{
+ using EnumType = DeviceEnergyManagement::CauseEnum;
+ switch (val)
+ {
+ case EnumType::kNormalCompletion:
+ case EnumType::kOffline:
+ case EnumType::kFault:
+ case EnumType::kUserOptOut:
+ case EnumType::kCancelled:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::CostTypeEnum val)
+{
+ using EnumType = DeviceEnergyManagement::CostTypeEnum;
+ switch (val)
+ {
+ case EnumType::kFinancial:
+ case EnumType::kGHGEmissions:
+ case EnumType::kComfort:
+ case EnumType::kTemperature:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::ESAStateEnum val)
+{
+ using EnumType = DeviceEnergyManagement::ESAStateEnum;
+ switch (val)
+ {
+ case EnumType::kOffline:
+ case EnumType::kOnline:
+ case EnumType::kFault:
+ case EnumType::kPowerAdjustActive:
+ case EnumType::kPaused:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::ESATypeEnum val)
+{
+ using EnumType = DeviceEnergyManagement::ESATypeEnum;
+ switch (val)
+ {
+ case EnumType::kEvse:
+ case EnumType::kSpaceHeating:
+ case EnumType::kWaterHeating:
+ case EnumType::kSpaceCooling:
+ case EnumType::kSpaceHeatingCooling:
+ case EnumType::kBatteryStorage:
+ case EnumType::kSolarPV:
+ case EnumType::kFridgeFreezer:
+ case EnumType::kWashingMachine:
+ case EnumType::kDishwasher:
+ case EnumType::kCooking:
+ case EnumType::kHomeWaterPump:
+ case EnumType::kIrrigationWaterPump:
+ case EnumType::kPoolPump:
+ case EnumType::kOther:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::ForecastUpdateReasonEnum val)
+{
+ using EnumType = DeviceEnergyManagement::ForecastUpdateReasonEnum;
+ switch (val)
+ {
+ case EnumType::kInternalOptimization:
+ case EnumType::kLocalOptimization:
+ case EnumType::kGridOptimization:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::OptOutStateEnum val)
+{
+ using EnumType = DeviceEnergyManagement::OptOutStateEnum;
+ switch (val)
+ {
+ case EnumType::kNoOptOut:
+ case EnumType::kLocalOptOut:
+ case EnumType::kGridOptOut:
+ case EnumType::kOptOut:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DeviceEnergyManagement::PowerAdjustReasonEnum val)
+{
+ using EnumType = DeviceEnergyManagement::PowerAdjustReasonEnum;
+ switch (val)
+ {
+ case EnumType::kNoAdjustment:
+ case EnumType::kLocalOptimizationAdjustment:
+ case EnumType::kGridOptimizationAdjustment:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyEvse::EnergyTransferStoppedReasonEnum val)
+{
+ using EnumType = EnergyEvse::EnergyTransferStoppedReasonEnum;
+ switch (val)
+ {
+ case EnumType::kEVStopped:
+ case EnumType::kEVSEStopped:
+ case EnumType::kOther:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyEvse::FaultStateEnum val)
+{
+ using EnumType = EnergyEvse::FaultStateEnum;
+ switch (val)
+ {
+ case EnumType::kNoError:
+ case EnumType::kMeterFailure:
+ case EnumType::kOverVoltage:
+ case EnumType::kUnderVoltage:
+ case EnumType::kOverCurrent:
+ case EnumType::kContactWetFailure:
+ case EnumType::kContactDryFailure:
+ case EnumType::kGroundFault:
+ case EnumType::kPowerLoss:
+ case EnumType::kPowerQuality:
+ case EnumType::kPilotShortCircuit:
+ case EnumType::kEmergencyStop:
+ case EnumType::kEVDisconnected:
+ case EnumType::kWrongPowerSupply:
+ case EnumType::kLiveNeutralSwap:
+ case EnumType::kOverTemperature:
+ case EnumType::kOther:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyEvse::StateEnum val)
+{
+ using EnumType = EnergyEvse::StateEnum;
+ switch (val)
+ {
+ case EnumType::kNotPluggedIn:
+ case EnumType::kPluggedInNoDemand:
+ case EnumType::kPluggedInDemand:
+ case EnumType::kPluggedInCharging:
+ case EnumType::kPluggedInDischarging:
+ case EnumType::kSessionEnding:
+ case EnumType::kFault:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyEvse::SupplyStateEnum val)
+{
+ using EnumType = EnergyEvse::SupplyStateEnum;
+ switch (val)
+ {
+ case EnumType::kDisabled:
+ case EnumType::kChargingEnabled:
+ case EnumType::kDischargingEnabled:
+ case EnumType::kDisabledError:
+ case EnumType::kDisabledDiagnostics:
+ case EnumType::kEnabled:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyPreference::EnergyPriorityEnum val)
+{
+ using EnumType = EnergyPreference::EnergyPriorityEnum;
+ switch (val)
+ {
+ case EnumType::kComfort:
+ case EnumType::kSpeed:
+ case EnumType::kEfficiency:
+ case EnumType::kWaterConsumption:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::AlarmCodeEnum val)
+{
+ using EnumType = DoorLock::AlarmCodeEnum;
+ switch (val)
+ {
+ case EnumType::kLockJammed:
+ case EnumType::kLockFactoryReset:
+ case EnumType::kLockRadioPowerCycled:
+ case EnumType::kWrongCodeEntryLimit:
+ case EnumType::kFrontEsceutcheonRemoved:
+ case EnumType::kDoorForcedOpen:
+ case EnumType::kDoorAjar:
+ case EnumType::kForcedUser:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::CredentialRuleEnum val)
+{
+ using EnumType = DoorLock::CredentialRuleEnum;
+ switch (val)
+ {
+ case EnumType::kSingle:
+ case EnumType::kDual:
+ case EnumType::kTri:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::CredentialTypeEnum val)
+{
+ using EnumType = DoorLock::CredentialTypeEnum;
+ switch (val)
+ {
+ case EnumType::kProgrammingPIN:
+ case EnumType::kPin:
+ case EnumType::kRfid:
+ case EnumType::kFingerprint:
+ case EnumType::kFingerVein:
+ case EnumType::kFace:
+ case EnumType::kAliroCredentialIssuerKey:
+ case EnumType::kAliroEvictableEndpointKey:
+ case EnumType::kAliroNonEvictableEndpointKey:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DataOperationTypeEnum val)
+{
+ using EnumType = DoorLock::DataOperationTypeEnum;
+ switch (val)
+ {
+ case EnumType::kAdd:
+ case EnumType::kClear:
+ case EnumType::kModify:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockState val)
+{
+ using EnumType = DoorLock::DlLockState;
+ switch (val)
+ {
+ case EnumType::kNotFullyLocked:
+ case EnumType::kLocked:
+ case EnumType::kUnlocked:
+ case EnumType::kUnlatched:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockType val)
+{
+ using EnumType = DoorLock::DlLockType;
+ switch (val)
+ {
+ case EnumType::kDeadBolt:
+ case EnumType::kMagnetic:
+ case EnumType::kOther:
+ case EnumType::kMortise:
+ case EnumType::kRim:
+ case EnumType::kLatchBolt:
+ case EnumType::kCylindricalLock:
+ case EnumType::kTubularLock:
+ case EnumType::kInterconnectedLock:
+ case EnumType::kDeadLatch:
+ case EnumType::kDoorFurniture:
+ case EnumType::kEurocylinder:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlStatus val)
+{
+ using EnumType = DoorLock::DlStatus;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kFailure:
+ case EnumType::kDuplicate:
+ case EnumType::kOccupied:
+ case EnumType::kInvalidField:
+ case EnumType::kResourceExhausted:
+ case EnumType::kNotFound:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockOperationEventCode val)
+{
+ using EnumType = DoorLock::DoorLockOperationEventCode;
+ switch (val)
+ {
+ case EnumType::kUnknownOrMfgSpecific:
+ case EnumType::kLock:
+ case EnumType::kUnlock:
+ case EnumType::kLockInvalidPinOrId:
+ case EnumType::kLockInvalidSchedule:
+ case EnumType::kUnlockInvalidPinOrId:
+ case EnumType::kUnlockInvalidSchedule:
+ case EnumType::kOneTouchLock:
+ case EnumType::kKeyLock:
+ case EnumType::kKeyUnlock:
+ case EnumType::kAutoLock:
+ case EnumType::kScheduleLock:
+ case EnumType::kScheduleUnlock:
+ case EnumType::kManualLock:
+ case EnumType::kManualUnlock:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockProgrammingEventCode val)
+{
+ using EnumType = DoorLock::DoorLockProgrammingEventCode;
+ switch (val)
+ {
+ case EnumType::kUnknownOrMfgSpecific:
+ case EnumType::kMasterCodeChanged:
+ case EnumType::kPinAdded:
+ case EnumType::kPinDeleted:
+ case EnumType::kPinChanged:
+ case EnumType::kIdAdded:
+ case EnumType::kIdDeleted:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockSetPinOrIdStatus val)
+{
+ using EnumType = DoorLock::DoorLockSetPinOrIdStatus;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kGeneralFailure:
+ case EnumType::kMemoryFull:
+ case EnumType::kDuplicateCodeError:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockUserStatus val)
+{
+ using EnumType = DoorLock::DoorLockUserStatus;
+ switch (val)
+ {
+ case EnumType::kAvailable:
+ case EnumType::kOccupiedEnabled:
+ case EnumType::kOccupiedDisabled:
+ case EnumType::kNotSupported:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockUserType val)
+{
+ using EnumType = DoorLock::DoorLockUserType;
+ switch (val)
+ {
+ case EnumType::kUnrestricted:
+ case EnumType::kYearDayScheduleUser:
+ case EnumType::kWeekDayScheduleUser:
+ case EnumType::kMasterUser:
+ case EnumType::kNonAccessUser:
+ case EnumType::kNotSupported:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorStateEnum val)
+{
+ using EnumType = DoorLock::DoorStateEnum;
+ switch (val)
+ {
+ case EnumType::kDoorOpen:
+ case EnumType::kDoorClosed:
+ case EnumType::kDoorJammed:
+ case EnumType::kDoorForcedOpen:
+ case EnumType::kDoorUnspecifiedError:
+ case EnumType::kDoorAjar:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::LockDataTypeEnum val)
+{
+ using EnumType = DoorLock::LockDataTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kProgrammingCode:
+ case EnumType::kUserIndex:
+ case EnumType::kWeekDaySchedule:
+ case EnumType::kYearDaySchedule:
+ case EnumType::kHolidaySchedule:
+ case EnumType::kPin:
+ case EnumType::kRfid:
+ case EnumType::kFingerprint:
+ case EnumType::kFingerVein:
+ case EnumType::kFace:
+ case EnumType::kAliroCredentialIssuerKey:
+ case EnumType::kAliroEvictableEndpointKey:
+ case EnumType::kAliroNonEvictableEndpointKey:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::LockOperationTypeEnum val)
+{
+ using EnumType = DoorLock::LockOperationTypeEnum;
+ switch (val)
+ {
+ case EnumType::kLock:
+ case EnumType::kUnlock:
+ case EnumType::kNonAccessUserEvent:
+ case EnumType::kForcedUserEvent:
+ case EnumType::kUnlatch:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::OperatingModeEnum val)
+{
+ using EnumType = DoorLock::OperatingModeEnum;
+ switch (val)
+ {
+ case EnumType::kNormal:
+ case EnumType::kVacation:
+ case EnumType::kPrivacy:
+ case EnumType::kNoRemoteLockUnlock:
+ case EnumType::kPassage:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::OperationErrorEnum val)
+{
+ using EnumType = DoorLock::OperationErrorEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kInvalidCredential:
+ case EnumType::kDisabledUserDenied:
+ case EnumType::kRestricted:
+ case EnumType::kInsufficientBattery:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::OperationSourceEnum val)
+{
+ using EnumType = DoorLock::OperationSourceEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kManual:
+ case EnumType::kProprietaryRemote:
+ case EnumType::kKeypad:
+ case EnumType::kAuto:
+ case EnumType::kButton:
+ case EnumType::kSchedule:
+ case EnumType::kRemote:
+ case EnumType::kRfid:
+ case EnumType::kBiometric:
+ case EnumType::kAliro:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::UserStatusEnum val)
+{
+ using EnumType = DoorLock::UserStatusEnum;
+ switch (val)
+ {
+ case EnumType::kAvailable:
+ case EnumType::kOccupiedEnabled:
+ case EnumType::kOccupiedDisabled:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::UserTypeEnum val)
+{
+ using EnumType = DoorLock::UserTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnrestrictedUser:
+ case EnumType::kYearDayScheduleUser:
+ case EnumType::kWeekDayScheduleUser:
+ case EnumType::kProgrammingUser:
+ case EnumType::kNonAccessUser:
+ case EnumType::kForcedUser:
+ case EnumType::kDisposableUser:
+ case EnumType::kExpiringUser:
+ case EnumType::kScheduleRestrictedUser:
+ case EnumType::kRemoteOnlyUser:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(WindowCovering::EndProductType val)
+{
+ using EnumType = WindowCovering::EndProductType;
+ switch (val)
+ {
+ case EnumType::kRollerShade:
+ case EnumType::kRomanShade:
+ case EnumType::kBalloonShade:
+ case EnumType::kWovenWood:
+ case EnumType::kPleatedShade:
+ case EnumType::kCellularShade:
+ case EnumType::kLayeredShade:
+ case EnumType::kLayeredShade2D:
+ case EnumType::kSheerShade:
+ case EnumType::kTiltOnlyInteriorBlind:
+ case EnumType::kInteriorBlind:
+ case EnumType::kVerticalBlindStripCurtain:
+ case EnumType::kInteriorVenetianBlind:
+ case EnumType::kExteriorVenetianBlind:
+ case EnumType::kLateralLeftCurtain:
+ case EnumType::kLateralRightCurtain:
+ case EnumType::kCentralCurtain:
+ case EnumType::kRollerShutter:
+ case EnumType::kExteriorVerticalScreen:
+ case EnumType::kAwningTerracePatio:
+ case EnumType::kAwningVerticalScreen:
+ case EnumType::kTiltOnlyPergola:
+ case EnumType::kSwingingShutter:
+ case EnumType::kSlidingShutter:
+ case EnumType::kUnknown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(WindowCovering::Type val)
+{
+ using EnumType = WindowCovering::Type;
+ switch (val)
+ {
+ case EnumType::kRollerShade:
+ case EnumType::kRollerShade2Motor:
+ case EnumType::kRollerShadeExterior:
+ case EnumType::kRollerShadeExterior2Motor:
+ case EnumType::kDrapery:
+ case EnumType::kAwning:
+ case EnumType::kShutter:
+ case EnumType::kTiltBlindTiltOnly:
+ case EnumType::kTiltBlindLiftAndTilt:
+ case EnumType::kProjectorScreen:
+ case EnumType::kUnknown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ServiceArea::OperationalStatusEnum val)
+{
+ using EnumType = ServiceArea::OperationalStatusEnum;
+ switch (val)
+ {
+ case EnumType::kPending:
+ case EnumType::kOperating:
+ case EnumType::kSkipped:
+ case EnumType::kCompleted:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ServiceArea::SelectAreasStatus val)
+{
+ using EnumType = ServiceArea::SelectAreasStatus;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kUnsupportedArea:
+ case EnumType::kInvalidInMode:
+ case EnumType::kInvalidSet:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ServiceArea::SkipAreaStatus val)
+{
+ using EnumType = ServiceArea::SkipAreaStatus;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kInvalidAreaList:
+ case EnumType::kInvalidInMode:
+ case EnumType::kInvalidSkippedArea:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(PumpConfigurationAndControl::ControlModeEnum val)
+{
+ using EnumType = PumpConfigurationAndControl::ControlModeEnum;
+ switch (val)
+ {
+ case EnumType::kConstantSpeed:
+ case EnumType::kConstantPressure:
+ case EnumType::kProportionalPressure:
+ case EnumType::kConstantFlow:
+ case EnumType::kConstantTemperature:
+ case EnumType::kAutomatic:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(PumpConfigurationAndControl::OperationModeEnum val)
+{
+ using EnumType = PumpConfigurationAndControl::OperationModeEnum;
+ switch (val)
+ {
+ case EnumType::kNormal:
+ case EnumType::kMinimum:
+ case EnumType::kMaximum:
+ case EnumType::kLocal:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ACCapacityFormatEnum val)
+{
+ using EnumType = Thermostat::ACCapacityFormatEnum;
+ switch (val)
+ {
+ case EnumType::kBTUh:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ACCompressorTypeEnum val)
+{
+ using EnumType = Thermostat::ACCompressorTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kT1:
+ case EnumType::kT2:
+ case EnumType::kT3:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ACLouverPositionEnum val)
+{
+ using EnumType = Thermostat::ACLouverPositionEnum;
+ switch (val)
+ {
+ case EnumType::kClosed:
+ case EnumType::kOpen:
+ case EnumType::kQuarter:
+ case EnumType::kHalf:
+ case EnumType::kThreeQuarters:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ACRefrigerantTypeEnum val)
+{
+ using EnumType = Thermostat::ACRefrigerantTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kR22:
+ case EnumType::kR410a:
+ case EnumType::kR407c:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ACTypeEnum val)
+{
+ using EnumType = Thermostat::ACTypeEnum;
+ switch (val)
+ {
+ case EnumType::kUnknown:
+ case EnumType::kCoolingFixed:
+ case EnumType::kHeatPumpFixed:
+ case EnumType::kCoolingInverter:
+ case EnumType::kHeatPumpInverter:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ControlSequenceOfOperationEnum val)
+{
+ using EnumType = Thermostat::ControlSequenceOfOperationEnum;
+ switch (val)
+ {
+ case EnumType::kCoolingOnly:
+ case EnumType::kCoolingWithReheat:
+ case EnumType::kHeatingOnly:
+ case EnumType::kHeatingWithReheat:
+ case EnumType::kCoolingAndHeating:
+ case EnumType::kCoolingAndHeatingWithReheat:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::PresetScenarioEnum val)
+{
+ using EnumType = Thermostat::PresetScenarioEnum;
+ switch (val)
+ {
+ case EnumType::kOccupied:
+ case EnumType::kUnoccupied:
+ case EnumType::kSleep:
+ case EnumType::kWake:
+ case EnumType::kVacation:
+ case EnumType::kGoingToSleep:
+ case EnumType::kUserDefined:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::SetpointChangeSourceEnum val)
+{
+ using EnumType = Thermostat::SetpointChangeSourceEnum;
+ switch (val)
+ {
+ case EnumType::kManual:
+ case EnumType::kSchedule:
+ case EnumType::kExternal:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::SetpointRaiseLowerModeEnum val)
+{
+ using EnumType = Thermostat::SetpointRaiseLowerModeEnum;
+ switch (val)
+ {
+ case EnumType::kHeat:
+ case EnumType::kCool:
+ case EnumType::kBoth:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::StartOfWeekEnum val)
+{
+ using EnumType = Thermostat::StartOfWeekEnum;
+ switch (val)
+ {
+ case EnumType::kSunday:
+ case EnumType::kMonday:
+ case EnumType::kTuesday:
+ case EnumType::kWednesday:
+ case EnumType::kThursday:
+ case EnumType::kFriday:
+ case EnumType::kSaturday:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::SystemModeEnum val)
+{
+ using EnumType = Thermostat::SystemModeEnum;
+ switch (val)
+ {
+ case EnumType::kOff:
+ case EnumType::kAuto:
+ case EnumType::kCool:
+ case EnumType::kHeat:
+ case EnumType::kEmergencyHeat:
+ case EnumType::kPrecooling:
+ case EnumType::kFanOnly:
+ case EnumType::kDry:
+ case EnumType::kSleep:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::TemperatureSetpointHoldEnum val)
+{
+ using EnumType = Thermostat::TemperatureSetpointHoldEnum;
+ switch (val)
+ {
+ case EnumType::kSetpointHoldOff:
+ case EnumType::kSetpointHoldOn:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatRunningModeEnum val)
+{
+ using EnumType = Thermostat::ThermostatRunningModeEnum;
+ switch (val)
+ {
+ case EnumType::kOff:
+ case EnumType::kCool:
+ case EnumType::kHeat:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::AirflowDirectionEnum val)
+{
+ using EnumType = FanControl::AirflowDirectionEnum;
+ switch (val)
+ {
+ case EnumType::kForward:
+ case EnumType::kReverse:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::FanModeEnum val)
+{
+ using EnumType = FanControl::FanModeEnum;
+ switch (val)
+ {
+ case EnumType::kOff:
+ case EnumType::kLow:
+ case EnumType::kMedium:
+ case EnumType::kHigh:
+ case EnumType::kOn:
+ case EnumType::kAuto:
+ case EnumType::kSmart:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::FanModeSequenceEnum val)
+{
+ using EnumType = FanControl::FanModeSequenceEnum;
+ switch (val)
+ {
+ case EnumType::kOffLowMedHigh:
+ case EnumType::kOffLowHigh:
+ case EnumType::kOffLowMedHighAuto:
+ case EnumType::kOffLowHighAuto:
+ case EnumType::kOffHighAuto:
+ case EnumType::kOffHigh:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::StepDirectionEnum val)
+{
+ using EnumType = FanControl::StepDirectionEnum;
+ switch (val)
+ {
+ case EnumType::kIncrease:
+ case EnumType::kDecrease:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ThermostatUserInterfaceConfiguration::KeypadLockoutEnum val)
+{
+ using EnumType = ThermostatUserInterfaceConfiguration::KeypadLockoutEnum;
+ switch (val)
+ {
+ case EnumType::kNoLockout:
+ case EnumType::kLockout1:
+ case EnumType::kLockout2:
+ case EnumType::kLockout3:
+ case EnumType::kLockout4:
+ case EnumType::kLockout5:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused))
+EnsureKnownEnumValue(ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum val)
+{
+ using EnumType = ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum;
+ switch (val)
+ {
+ case EnumType::kScheduleProgrammingPermitted:
+ case EnumType::kScheduleProgrammingDenied:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum val)
+{
+ using EnumType = ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum;
+ switch (val)
+ {
+ case EnumType::kCelsius:
+ case EnumType::kFahrenheit:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorLoopActionEnum val)
+{
+ using EnumType = ColorControl::ColorLoopActionEnum;
+ switch (val)
+ {
+ case EnumType::kDeactivate:
+ case EnumType::kActivateFromColorLoopStartEnhancedHue:
+ case EnumType::kActivateFromEnhancedCurrentHue:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorLoopDirectionEnum val)
+{
+ using EnumType = ColorControl::ColorLoopDirectionEnum;
+ switch (val)
+ {
+ case EnumType::kDecrement:
+ case EnumType::kIncrement:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorModeEnum val)
+{
+ using EnumType = ColorControl::ColorModeEnum;
+ switch (val)
+ {
+ case EnumType::kCurrentHueAndCurrentSaturation:
+ case EnumType::kCurrentXAndCurrentY:
+ case EnumType::kColorTemperatureMireds:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::DirectionEnum val)
+{
+ using EnumType = ColorControl::DirectionEnum;
+ switch (val)
+ {
+ case EnumType::kShortest:
+ case EnumType::kLongest:
+ case EnumType::kUp:
+ case EnumType::kDown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::DriftCompensationEnum val)
+{
+ using EnumType = ColorControl::DriftCompensationEnum;
+ switch (val)
+ {
+ case EnumType::kNone:
+ case EnumType::kOtherOrUnknown:
+ case EnumType::kTemperatureMonitoring:
+ case EnumType::kOpticalLuminanceMonitoringAndFeedback:
+ case EnumType::kOpticalColorMonitoringAndFeedback:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::EnhancedColorModeEnum val)
+{
+ using EnumType = ColorControl::EnhancedColorModeEnum;
+ switch (val)
+ {
+ case EnumType::kCurrentHueAndCurrentSaturation:
+ case EnumType::kCurrentXAndCurrentY:
+ case EnumType::kColorTemperatureMireds:
+ case EnumType::kEnhancedCurrentHueAndCurrentSaturation:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::MoveModeEnum val)
+{
+ using EnumType = ColorControl::MoveModeEnum;
+ switch (val)
+ {
+ case EnumType::kStop:
+ case EnumType::kUp:
+ case EnumType::kDown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::StepModeEnum val)
+{
+ using EnumType = ColorControl::StepModeEnum;
+ switch (val)
+ {
+ case EnumType::kUp:
+ case EnumType::kDown:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(IlluminanceMeasurement::LightSensorTypeEnum val)
+{
+ using EnumType = IlluminanceMeasurement::LightSensorTypeEnum;
+ switch (val)
+ {
+ case EnumType::kPhotodiode:
+ case EnumType::kCmos:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(OccupancySensing::OccupancySensorTypeEnum val)
+{
+ using EnumType = OccupancySensing::OccupancySensorTypeEnum;
+ switch (val)
+ {
+ case EnumType::kPir:
+ case EnumType::kUltrasonic:
+ case EnumType::kPIRAndUltrasonic:
+ case EnumType::kPhysicalContact:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::ChannelTypeEnum val)
+{
+ using EnumType = Channel::ChannelTypeEnum;
+ switch (val)
+ {
+ case EnumType::kSatellite:
+ case EnumType::kCable:
+ case EnumType::kTerrestrial:
+ case EnumType::kOtt:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::LineupInfoTypeEnum val)
+{
+ using EnumType = Channel::LineupInfoTypeEnum;
+ switch (val)
+ {
+ case EnumType::kMso:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::StatusEnum val)
+{
+ using EnumType = Channel::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kMultipleMatches:
+ case EnumType::kNoMatches:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(TargetNavigator::StatusEnum val)
+{
+ using EnumType = TargetNavigator::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kTargetNotFound:
+ case EnumType::kNotAllowed:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::CharacteristicEnum val)
+{
+ using EnumType = MediaPlayback::CharacteristicEnum;
+ switch (val)
+ {
+ case EnumType::kForcedSubtitles:
+ case EnumType::kDescribesVideo:
+ case EnumType::kEasyToRead:
+ case EnumType::kFrameBased:
+ case EnumType::kMainProgram:
+ case EnumType::kOriginalContent:
+ case EnumType::kVoiceOverTranslation:
+ case EnumType::kCaption:
+ case EnumType::kSubtitle:
+ case EnumType::kAlternate:
+ case EnumType::kSupplementary:
+ case EnumType::kCommentary:
+ case EnumType::kDubbedTranslation:
+ case EnumType::kDescription:
+ case EnumType::kMetadata:
+ case EnumType::kEnhancedAudioIntelligibility:
+ case EnumType::kEmergency:
+ case EnumType::kKaraoke:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::PlaybackStateEnum val)
+{
+ using EnumType = MediaPlayback::PlaybackStateEnum;
+ switch (val)
+ {
+ case EnumType::kPlaying:
+ case EnumType::kPaused:
+ case EnumType::kNotPlaying:
+ case EnumType::kBuffering:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::StatusEnum val)
+{
+ using EnumType = MediaPlayback::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kInvalidStateForCommand:
+ case EnumType::kNotAllowed:
+ case EnumType::kNotActive:
+ case EnumType::kSpeedOutOfRange:
+ case EnumType::kSeekOutOfRange:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(MediaInput::InputTypeEnum val)
+{
+ using EnumType = MediaInput::InputTypeEnum;
+ switch (val)
+ {
+ case EnumType::kInternal:
+ case EnumType::kAux:
+ case EnumType::kCoax:
+ case EnumType::kComposite:
+ case EnumType::kHdmi:
+ case EnumType::kInput:
+ case EnumType::kLine:
+ case EnumType::kOptical:
+ case EnumType::kVideo:
+ case EnumType::kScart:
+ case EnumType::kUsb:
+ case EnumType::kOther:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(KeypadInput::CECKeyCodeEnum val)
+{
+ using EnumType = KeypadInput::CECKeyCodeEnum;
+ switch (val)
+ {
+ case EnumType::kSelect:
+ case EnumType::kUp:
+ case EnumType::kDown:
+ case EnumType::kLeft:
+ case EnumType::kRight:
+ case EnumType::kRightUp:
+ case EnumType::kRightDown:
+ case EnumType::kLeftUp:
+ case EnumType::kLeftDown:
+ case EnumType::kRootMenu:
+ case EnumType::kSetupMenu:
+ case EnumType::kContentsMenu:
+ case EnumType::kFavoriteMenu:
+ case EnumType::kExit:
+ case EnumType::kMediaTopMenu:
+ case EnumType::kMediaContextSensitiveMenu:
+ case EnumType::kNumberEntryMode:
+ case EnumType::kNumber11:
+ case EnumType::kNumber12:
+ case EnumType::kNumber0OrNumber10:
+ case EnumType::kNumbers1:
+ case EnumType::kNumbers2:
+ case EnumType::kNumbers3:
+ case EnumType::kNumbers4:
+ case EnumType::kNumbers5:
+ case EnumType::kNumbers6:
+ case EnumType::kNumbers7:
+ case EnumType::kNumbers8:
+ case EnumType::kNumbers9:
+ case EnumType::kDot:
+ case EnumType::kEnter:
+ case EnumType::kClear:
+ case EnumType::kNextFavorite:
+ case EnumType::kChannelUp:
+ case EnumType::kChannelDown:
+ case EnumType::kPreviousChannel:
+ case EnumType::kSoundSelect:
+ case EnumType::kInputSelect:
+ case EnumType::kDisplayInformation:
+ case EnumType::kHelp:
+ case EnumType::kPageUp:
+ case EnumType::kPageDown:
+ case EnumType::kPower:
+ case EnumType::kVolumeUp:
+ case EnumType::kVolumeDown:
+ case EnumType::kMute:
+ case EnumType::kPlay:
+ case EnumType::kStop:
+ case EnumType::kPause:
+ case EnumType::kRecord:
+ case EnumType::kRewind:
+ case EnumType::kFastForward:
+ case EnumType::kEject:
+ case EnumType::kForward:
+ case EnumType::kBackward:
+ case EnumType::kStopRecord:
+ case EnumType::kPauseRecord:
+ case EnumType::kReserved:
+ case EnumType::kAngle:
+ case EnumType::kSubPicture:
+ case EnumType::kVideoOnDemand:
+ case EnumType::kElectronicProgramGuide:
+ case EnumType::kTimerProgramming:
+ case EnumType::kInitialConfiguration:
+ case EnumType::kSelectBroadcastType:
+ case EnumType::kSelectSoundPresentation:
+ case EnumType::kPlayFunction:
+ case EnumType::kPausePlayFunction:
+ case EnumType::kRecordFunction:
+ case EnumType::kPauseRecordFunction:
+ case EnumType::kStopFunction:
+ case EnumType::kMuteFunction:
+ case EnumType::kRestoreVolumeFunction:
+ case EnumType::kTuneFunction:
+ case EnumType::kSelectMediaFunction:
+ case EnumType::kSelectAvInputFunction:
+ case EnumType::kSelectAudioInputFunction:
+ case EnumType::kPowerToggleFunction:
+ case EnumType::kPowerOffFunction:
+ case EnumType::kPowerOnFunction:
+ case EnumType::kF1Blue:
+ case EnumType::kF2Red:
+ case EnumType::kF3Green:
+ case EnumType::kF4Yellow:
+ case EnumType::kF5:
+ case EnumType::kData:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(KeypadInput::StatusEnum val)
+{
+ using EnumType = KeypadInput::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kUnsupportedKey:
+ case EnumType::kInvalidKeyInCurrentState:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::CharacteristicEnum val)
+{
+ using EnumType = ContentLauncher::CharacteristicEnum;
+ switch (val)
+ {
+ case EnumType::kForcedSubtitles:
+ case EnumType::kDescribesVideo:
+ case EnumType::kEasyToRead:
+ case EnumType::kFrameBased:
+ case EnumType::kMainProgram:
+ case EnumType::kOriginalContent:
+ case EnumType::kVoiceOverTranslation:
+ case EnumType::kCaption:
+ case EnumType::kSubtitle:
+ case EnumType::kAlternate:
+ case EnumType::kSupplementary:
+ case EnumType::kCommentary:
+ case EnumType::kDubbedTranslation:
+ case EnumType::kDescription:
+ case EnumType::kMetadata:
+ case EnumType::kEnhancedAudioIntelligibility:
+ case EnumType::kEmergency:
+ case EnumType::kKaraoke:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::MetricTypeEnum val)
+{
+ using EnumType = ContentLauncher::MetricTypeEnum;
+ switch (val)
+ {
+ case EnumType::kPixels:
+ case EnumType::kPercentage:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::ParameterEnum val)
+{
+ using EnumType = ContentLauncher::ParameterEnum;
+ switch (val)
+ {
+ case EnumType::kActor:
+ case EnumType::kChannel:
+ case EnumType::kCharacter:
+ case EnumType::kDirector:
+ case EnumType::kEvent:
+ case EnumType::kFranchise:
+ case EnumType::kGenre:
+ case EnumType::kLeague:
+ case EnumType::kPopularity:
+ case EnumType::kProvider:
+ case EnumType::kSport:
+ case EnumType::kSportsTeam:
+ case EnumType::kType:
+ case EnumType::kVideo:
+ case EnumType::kSeason:
+ case EnumType::kEpisode:
+ case EnumType::kAny:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::StatusEnum val)
+{
+ using EnumType = ContentLauncher::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kURLNotAvailable:
+ case EnumType::kAuthFailed:
+ case EnumType::kTextTrackNotAvailable:
+ case EnumType::kAudioTrackNotAvailable:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(AudioOutput::OutputTypeEnum val)
+{
+ using EnumType = AudioOutput::OutputTypeEnum;
+ switch (val)
+ {
+ case EnumType::kHdmi:
+ case EnumType::kBt:
+ case EnumType::kOptical:
+ case EnumType::kHeadphone:
+ case EnumType::kInternal:
+ case EnumType::kOther:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ApplicationLauncher::StatusEnum val)
+{
+ using EnumType = ApplicationLauncher::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kAppNotAvailable:
+ case EnumType::kSystemBusy:
+ case EnumType::kPendingUserApproval:
+ case EnumType::kDownloading:
+ case EnumType::kInstalling:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ApplicationBasic::ApplicationStatusEnum val)
+{
+ using EnumType = ApplicationBasic::ApplicationStatusEnum;
+ switch (val)
+ {
+ case EnumType::kStopped:
+ case EnumType::kActiveVisibleFocus:
+ case EnumType::kActiveHidden:
+ case EnumType::kActiveVisibleNotFocus:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ContentAppObserver::StatusEnum val)
+{
+ using EnumType = ContentAppObserver::StatusEnum;
+ switch (val)
+ {
+ case EnumType::kSuccess:
+ case EnumType::kUnexpectedData:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(ZoneManagement::StatusCodeEnum val)
+{
+ using EnumType = ZoneManagement::StatusCodeEnum;
+ switch (val)
+ {
+ case EnumType::kZoneNotFound:
+ case EnumType::kZoneInUse:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ZoneManagement::ZoneEventStoppedReasonEnum val)
+{
+ using EnumType = ZoneManagement::ZoneEventStoppedReasonEnum;
+ switch (val)
+ {
+ case EnumType::kActionStopped:
+ case EnumType::kTimeout:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ZoneManagement::ZoneEventTriggeredReasonEnum val)
+{
+ using EnumType = ZoneManagement::ZoneEventTriggeredReasonEnum;
+ switch (val)
+ {
+ case EnumType::kMotion:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ZoneManagement::ZoneSourceEnum val)
+{
+ using EnumType = ZoneManagement::ZoneSourceEnum;
+ switch (val)
+ {
+ case EnumType::kMfg:
+ case EnumType::kUser:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ZoneManagement::ZoneTypeEnum val)
+{
+ using EnumType = ZoneManagement::ZoneTypeEnum;
+ switch (val)
+ {
+ case EnumType::kTwoDCARTZone:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(ZoneManagement::ZoneUseEnum val)
+{
+ using EnumType = ZoneManagement::ZoneUseEnum;
+ switch (val)
+ {
+ case EnumType::kMotion:
+ case EnumType::kPrivacy:
+ case EnumType::kFocus:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(CameraAvStreamManagement::AudioCodecEnum val)
+{
+ using EnumType = CameraAvStreamManagement::AudioCodecEnum;
+ switch (val)
+ {
+ case EnumType::kOpus:
+ case EnumType::kAacLc:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(CameraAvStreamManagement::ImageCodecEnum val)
+{
+ using EnumType = CameraAvStreamManagement::ImageCodecEnum;
+ switch (val)
+ {
+ case EnumType::kJpeg:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(CameraAvStreamManagement::TriStateAutoEnum val)
+{
+ using EnumType = CameraAvStreamManagement::TriStateAutoEnum;
+ switch (val)
+ {
+ case EnumType::kOff:
+ case EnumType::kOn:
+ case EnumType::kAuto:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(CameraAvStreamManagement::TwoWayTalkSupportTypeEnum val)
+{
+ using EnumType = CameraAvStreamManagement::TwoWayTalkSupportTypeEnum;
+ switch (val)
+ {
+ case EnumType::kNotSupported:
+ case EnumType::kHalfDuplex:
+ case EnumType::kFullDuplex:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+static auto __attribute__((unused)) EnsureKnownEnumValue(CameraAvStreamManagement::VideoCodecEnum val)
+{
+ using EnumType = CameraAvStreamManagement::VideoCodecEnum;
+ switch (val)
+ {
+ case EnumType::kH264:
+ case EnumType::kHevc:
+ case EnumType::kVvc:
+ case EnumType::kAv1:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(UnitTesting::SimpleEnum val)
+{
+ using EnumType = UnitTesting::SimpleEnum;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kValueA:
+ case EnumType::kValueB:
+ case EnumType::kValueC:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+static auto __attribute__((unused)) EnsureKnownEnumValue(FaultInjection::FaultType val)
+{
+ using EnumType = FaultInjection::FaultType;
+ switch (val)
+ {
+ case EnumType::kUnspecified:
+ case EnumType::kSystemFault:
+ case EnumType::kInetFault:
+ case EnumType::kChipFault:
+ case EnumType::kCertFault:
+ return val;
+ default:
+ return EnumType::kUnknownEnumValue;
+ }
+}
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h
new file mode 100644
index 00000000000000..39562501ce09fd
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h
@@ -0,0 +1,5747 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <stdint.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace detail {
+// Enums shared across multiple clusters.
+
+// Enum for ChangeIndicationEnum
+enum class ChangeIndicationEnum : uint8_t
+{
+ kOk = 0x00,
+ kWarning = 0x01,
+ kCritical = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for DegradationDirectionEnum
+enum class DegradationDirectionEnum : uint8_t
+{
+ kUp = 0x00,
+ kDown = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for LevelValueEnum
+enum class LevelValueEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kLow = 0x01,
+ kMedium = 0x02,
+ kHigh = 0x03,
+ kCritical = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for MeasurementMediumEnum
+enum class MeasurementMediumEnum : uint8_t
+{
+ kAir = 0x00,
+ kWater = 0x01,
+ kSoil = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for MeasurementTypeEnum
+enum class MeasurementTypeEnum : uint16_t
+{
+ kUnspecified = 0x00,
+ kVoltage = 0x01,
+ kActiveCurrent = 0x02,
+ kReactiveCurrent = 0x03,
+ kApparentCurrent = 0x04,
+ kActivePower = 0x05,
+ kReactivePower = 0x06,
+ kApparentPower = 0x07,
+ kRMSVoltage = 0x08,
+ kRMSCurrent = 0x09,
+ kRMSPower = 0x0A,
+ kFrequency = 0x0B,
+ kPowerFactor = 0x0C,
+ kNeutralCurrent = 0x0D,
+ kElectricalEnergy = 0x0E,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 15,
+};
+
+// Enum for MeasurementUnitEnum
+enum class MeasurementUnitEnum : uint8_t
+{
+ kPpm = 0x00,
+ kPpb = 0x01,
+ kPpt = 0x02,
+ kMgm3 = 0x03,
+ kUgm3 = 0x04,
+ kNgm3 = 0x05,
+ kPm3 = 0x06,
+ kBqm3 = 0x07,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 8,
+};
+
+// Enum for ProductIdentifierTypeEnum
+enum class ProductIdentifierTypeEnum : uint8_t
+{
+ kUpc = 0x00,
+ kGtin8 = 0x01,
+ kEan = 0x02,
+ kGtin14 = 0x03,
+ kOem = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for StreamUsageEnum
+enum class StreamUsageEnum : uint8_t
+{
+ kInternal = 0x00,
+ kRecording = 0x01,
+ kAnalysis = 0x02,
+ kLiveView = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for WebRTCEndReasonEnum
+enum class WebRTCEndReasonEnum : uint8_t
+{
+ kIceFailed = 0x00,
+ kIceTimeout = 0x01,
+ kUserHangup = 0x02,
+ kUserBusy = 0x03,
+ kReplaced = 0x04,
+ kNoUserMedia = 0x05,
+ kInviteTimeout = 0x06,
+ kAnsweredElsewhere = 0x07,
+ kOutOfResources = 0x08,
+ kMediaTimeout = 0x09,
+ kLowPower = 0x0A,
+ kUnknownReason = 0x0B,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 12,
+};
+
+// Bitmaps shared across multiple clusters.
+
+// Bitmap for WebRTCMetadataOptions
+enum class WebRTCMetadataOptions : uint8_t
+{
+ kDataTLV = 0x1,
+};
+
+} // namespace detail
+
+namespace Globals {
+// Global enums.
+
+// Enum for AreaTypeTag
+enum class AreaTypeTag : uint8_t
+{
+ kAisle = 0x00,
+ kAttic = 0x01,
+ kBackDoor = 0x02,
+ kBackYard = 0x03,
+ kBalcony = 0x04,
+ kBallroom = 0x05,
+ kBathroom = 0x06,
+ kBedroom = 0x07,
+ kBorder = 0x08,
+ kBoxroom = 0x09,
+ kBreakfastRoom = 0x0A,
+ kCarport = 0x0B,
+ kCellar = 0x0C,
+ kCloakroom = 0x0D,
+ kCloset = 0x0E,
+ kConservatory = 0x0F,
+ kCorridor = 0x10,
+ kCraftRoom = 0x11,
+ kCupboard = 0x12,
+ kDeck = 0x13,
+ kDen = 0x14,
+ kDining = 0x15,
+ kDrawingRoom = 0x16,
+ kDressingRoom = 0x17,
+ kDriveway = 0x18,
+ kElevator = 0x19,
+ kEnsuite = 0x1A,
+ kEntrance = 0x1B,
+ kEntryway = 0x1C,
+ kFamilyRoom = 0x1D,
+ kFoyer = 0x1E,
+ kFrontDoor = 0x1F,
+ kFrontYard = 0x20,
+ kGameRoom = 0x21,
+ kGarage = 0x22,
+ kGarageDoor = 0x23,
+ kGarden = 0x24,
+ kGardenDoor = 0x25,
+ kGuestBathroom = 0x26,
+ kGuestBedroom = 0x27,
+ kGuestRestroom = 0x28,
+ kGuestRoom = 0x29,
+ kGym = 0x2A,
+ kHallway = 0x2B,
+ kHearthRoom = 0x2C,
+ kKidsRoom = 0x2D,
+ kKidsBedroom = 0x2E,
+ kKitchen = 0x2F,
+ kLarder = 0x30,
+ kLaundryRoom = 0x31,
+ kLawn = 0x32,
+ kLibrary = 0x33,
+ kLivingRoom = 0x34,
+ kLounge = 0x35,
+ kMediaTvRoom = 0x36,
+ kMudRoom = 0x37,
+ kMusicRoom = 0x38,
+ kNursery = 0x39,
+ kOffice = 0x3A,
+ kOutdoorKitchen = 0x3B,
+ kOutside = 0x3C,
+ kPantry = 0x3D,
+ kParkingLot = 0x3E,
+ kParlor = 0x3F,
+ kPatio = 0x40,
+ kPlayRoom = 0x41,
+ kPoolRoom = 0x42,
+ kPorch = 0x43,
+ kPrimaryBathroom = 0x44,
+ kPrimaryBedroom = 0x45,
+ kRamp = 0x46,
+ kReceptionRoom = 0x47,
+ kRecreationRoom = 0x48,
+ kRestroom = 0x49,
+ kRoof = 0x4A,
+ kSauna = 0x4B,
+ kScullery = 0x4C,
+ kSewingRoom = 0x4D,
+ kShed = 0x4E,
+ kSideDoor = 0x4F,
+ kSideYard = 0x50,
+ kSittingRoom = 0x51,
+ kSnug = 0x52,
+ kSpa = 0x53,
+ kStaircase = 0x54,
+ kSteamRoom = 0x55,
+ kStorageRoom = 0x56,
+ kStudio = 0x57,
+ kStudy = 0x58,
+ kSunRoom = 0x59,
+ kSwimmingPool = 0x5A,
+ kTerrace = 0x5B,
+ kUtilityRoom = 0x5C,
+ kWard = 0x5D,
+ kWorkshop = 0x5E,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 95,
+};
+
+// Enum for AtomicRequestTypeEnum
+enum class AtomicRequestTypeEnum : uint8_t
+{
+ kBeginWrite = 0x00,
+ kCommitWrite = 0x01,
+ kRollbackWrite = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for FloorSurfaceTag
+enum class FloorSurfaceTag : uint8_t
+{
+ kCarpet = 0x00,
+ kCeramic = 0x01,
+ kConcrete = 0x02,
+ kCork = 0x03,
+ kDeepCarpet = 0x04,
+ kDirt = 0x05,
+ kEngineeredWood = 0x06,
+ kGlass = 0x07,
+ kGrass = 0x08,
+ kHardwood = 0x09,
+ kLaminate = 0x0A,
+ kLinoleum = 0x0B,
+ kMat = 0x0C,
+ kMetal = 0x0D,
+ kPlastic = 0x0E,
+ kPolishedConcrete = 0x0F,
+ kRubber = 0x10,
+ kRug = 0x11,
+ kSand = 0x12,
+ kStone = 0x13,
+ kTatami = 0x14,
+ kTerrazzo = 0x15,
+ kTile = 0x16,
+ kVinyl = 0x17,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 24,
+};
+
+// Enum for LandmarkTag
+enum class LandmarkTag : uint8_t
+{
+ kAirConditioner = 0x00,
+ kAirPurifier = 0x01,
+ kBackDoor = 0x02,
+ kBarStool = 0x03,
+ kBathMat = 0x04,
+ kBathtub = 0x05,
+ kBed = 0x06,
+ kBookshelf = 0x07,
+ kChair = 0x08,
+ kChristmasTree = 0x09,
+ kCoatRack = 0x0A,
+ kCoffeeTable = 0x0B,
+ kCookingRange = 0x0C,
+ kCouch = 0x0D,
+ kCountertop = 0x0E,
+ kCradle = 0x0F,
+ kCrib = 0x10,
+ kDesk = 0x11,
+ kDiningTable = 0x12,
+ kDishwasher = 0x13,
+ kDoor = 0x14,
+ kDresser = 0x15,
+ kLaundryDryer = 0x16,
+ kFan = 0x17,
+ kFireplace = 0x18,
+ kFreezer = 0x19,
+ kFrontDoor = 0x1A,
+ kHighChair = 0x1B,
+ kKitchenIsland = 0x1C,
+ kLamp = 0x1D,
+ kLitterBox = 0x1E,
+ kMirror = 0x1F,
+ kNightstand = 0x20,
+ kOven = 0x21,
+ kPetBed = 0x22,
+ kPetBowl = 0x23,
+ kPetCrate = 0x24,
+ kRefrigerator = 0x25,
+ kScratchingPost = 0x26,
+ kShoeRack = 0x27,
+ kShower = 0x28,
+ kSideDoor = 0x29,
+ kSink = 0x2A,
+ kSofa = 0x2B,
+ kStove = 0x2C,
+ kTable = 0x2D,
+ kToilet = 0x2E,
+ kTrashCan = 0x2F,
+ kLaundryWasher = 0x30,
+ kWindow = 0x31,
+ kWineCooler = 0x32,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 51,
+};
+
+// Enum for PositionTag
+enum class PositionTag : uint8_t
+{
+ kLeft = 0x00,
+ kRight = 0x01,
+ kTop = 0x02,
+ kBottom = 0x03,
+ kMiddle = 0x04,
+ kRow = 0x05,
+ kColumn = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for RelativePositionTag
+enum class RelativePositionTag : uint8_t
+{
+ kUnder = 0x00,
+ kNextTo = 0x01,
+ kAround = 0x02,
+ kOn = 0x03,
+ kAbove = 0x04,
+ kFrontOf = 0x05,
+ kBehind = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for TestGlobalEnum
+enum class TestGlobalEnum : uint8_t
+{
+ kSomeValue = 0x00,
+ kSomeOtherValue = 0x01,
+ kFinalValue = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for ThreeLevelAutoEnum
+enum class ThreeLevelAutoEnum : uint8_t
+{
+ kLow = 0x00,
+ kMedium = 0x01,
+ kHigh = 0x02,
+ kAutomatic = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Global bitmaps.
+
+// Bitmap for TestGlobalBitmap
+enum class TestGlobalBitmap : uint32_t
+{
+ kFirstBit = 0x1,
+ kSecondBit = 0x2,
+};
+
+} // namespace Globals
+
+namespace Identify {
+
+// Enum for EffectIdentifierEnum
+enum class EffectIdentifierEnum : uint8_t
+{
+ kBlink = 0x00,
+ kBreathe = 0x01,
+ kOkay = 0x02,
+ kChannelChange = 0x0B,
+ kFinishEffect = 0xFE,
+ kStopEffect = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for EffectVariantEnum
+enum class EffectVariantEnum : uint8_t
+{
+ kDefault = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Enum for IdentifyTypeEnum
+enum class IdentifyTypeEnum : uint8_t
+{
+ kNone = 0x00,
+ kLightOutput = 0x01,
+ kVisibleIndicator = 0x02,
+ kAudibleBeep = 0x03,
+ kDisplay = 0x04,
+ kActuator = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+} // namespace Identify
+
+namespace Groups {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kGroupNames = 0x1,
+};
+
+// Bitmap for NameSupportBitmap
+enum class NameSupportBitmap : uint8_t
+{
+ kGroupNames = 0x80,
+};
+} // namespace Groups
+
+namespace OnOff {
+
+// Enum for DelayedAllOffEffectVariantEnum
+enum class DelayedAllOffEffectVariantEnum : uint8_t
+{
+ kDelayedOffFastFade = 0x00,
+ kNoFade = 0x01,
+ kDelayedOffSlowFade = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for DyingLightEffectVariantEnum
+enum class DyingLightEffectVariantEnum : uint8_t
+{
+ kDyingLightFadeOff = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Enum for EffectIdentifierEnum
+enum class EffectIdentifierEnum : uint8_t
+{
+ kDelayedAllOff = 0x00,
+ kDyingLight = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for StartUpOnOffEnum
+enum class StartUpOnOffEnum : uint8_t
+{
+ kOff = 0x00,
+ kOn = 0x01,
+ kToggle = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kLighting = 0x1,
+ kDeadFrontBehavior = 0x2,
+ kOffOnly = 0x4,
+};
+
+// Bitmap for OnOffControlBitmap
+enum class OnOffControlBitmap : uint8_t
+{
+ kAcceptOnlyWhenOn = 0x1,
+};
+} // namespace OnOff
+
+namespace LevelControl {
+
+// Enum for MoveModeEnum
+enum class MoveModeEnum : uint8_t
+{
+ kUp = 0x00,
+ kDown = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for StepModeEnum
+enum class StepModeEnum : uint8_t
+{
+ kUp = 0x00,
+ kDown = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+ kLighting = 0x2,
+ kFrequency = 0x4,
+};
+
+// Bitmap for OptionsBitmap
+enum class OptionsBitmap : uint8_t
+{
+ kExecuteIfOff = 0x1,
+ kCoupleColorTempToLevel = 0x2,
+};
+} // namespace LevelControl
+
+namespace PulseWidthModulation {} // namespace PulseWidthModulation
+
+namespace Descriptor {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTagList = 0x1,
+};
+} // namespace Descriptor
+
+namespace Binding {} // namespace Binding
+
+namespace AccessControl {
+
+// Enum for AccessControlEntryAuthModeEnum
+enum class AccessControlEntryAuthModeEnum : uint8_t
+{
+ kPase = 0x01,
+ kCase = 0x02,
+ kGroup = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for AccessControlEntryPrivilegeEnum
+enum class AccessControlEntryPrivilegeEnum : uint8_t
+{
+ kView = 0x01,
+ kProxyView = 0x02,
+ kOperate = 0x03,
+ kManage = 0x04,
+ kAdminister = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for AccessRestrictionTypeEnum
+enum class AccessRestrictionTypeEnum : uint8_t
+{
+ kAttributeAccessForbidden = 0x00,
+ kAttributeWriteForbidden = 0x01,
+ kCommandForbidden = 0x02,
+ kEventForbidden = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for ChangeTypeEnum
+enum class ChangeTypeEnum : uint8_t
+{
+ kChanged = 0x00,
+ kAdded = 0x01,
+ kRemoved = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kExtension = 0x1,
+ kManagedDevice = 0x2,
+};
+} // namespace AccessControl
+
+namespace Actions {
+
+// Enum for ActionErrorEnum
+enum class ActionErrorEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kInterrupted = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ActionStateEnum
+enum class ActionStateEnum : uint8_t
+{
+ kInactive = 0x00,
+ kActive = 0x01,
+ kPaused = 0x02,
+ kDisabled = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for ActionTypeEnum
+enum class ActionTypeEnum : uint8_t
+{
+ kOther = 0x00,
+ kScene = 0x01,
+ kSequence = 0x02,
+ kAutomation = 0x03,
+ kException = 0x04,
+ kNotification = 0x05,
+ kAlarm = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for EndpointListTypeEnum
+enum class EndpointListTypeEnum : uint8_t
+{
+ kOther = 0x00,
+ kRoom = 0x01,
+ kZone = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for CommandBits
+enum class CommandBits : uint16_t
+{
+ kInstantAction = 0x1,
+ kInstantActionWithTransition = 0x2,
+ kStartAction = 0x4,
+ kStartActionWithDuration = 0x8,
+ kStopAction = 0x10,
+ kPauseAction = 0x20,
+ kPauseActionWithDuration = 0x40,
+ kResumeAction = 0x80,
+ kEnableAction = 0x100,
+ kEnableActionWithDuration = 0x200,
+ kDisableAction = 0x400,
+ kDisableActionWithDuration = 0x800,
+};
+} // namespace Actions
+
+namespace BasicInformation {
+
+// Enum for ColorEnum
+enum class ColorEnum : uint8_t
+{
+ kBlack = 0x00,
+ kNavy = 0x01,
+ kGreen = 0x02,
+ kTeal = 0x03,
+ kMaroon = 0x04,
+ kPurple = 0x05,
+ kOlive = 0x06,
+ kGray = 0x07,
+ kBlue = 0x08,
+ kLime = 0x09,
+ kAqua = 0x0A,
+ kRed = 0x0B,
+ kFuchsia = 0x0C,
+ kYellow = 0x0D,
+ kWhite = 0x0E,
+ kNickel = 0x0F,
+ kChrome = 0x10,
+ kBrass = 0x11,
+ kCopper = 0x12,
+ kSilver = 0x13,
+ kGold = 0x14,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 21,
+};
+
+// Enum for ProductFinishEnum
+enum class ProductFinishEnum : uint8_t
+{
+ kOther = 0x00,
+ kMatte = 0x01,
+ kSatin = 0x02,
+ kPolished = 0x03,
+ kRugged = 0x04,
+ kFabric = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+} // namespace BasicInformation
+
+namespace OtaSoftwareUpdateProvider {
+
+// Enum for ApplyUpdateActionEnum
+enum class ApplyUpdateActionEnum : uint8_t
+{
+ kProceed = 0x00,
+ kAwaitNextAction = 0x01,
+ kDiscontinue = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for DownloadProtocolEnum
+enum class DownloadProtocolEnum : uint8_t
+{
+ kBDXSynchronous = 0x00,
+ kBDXAsynchronous = 0x01,
+ kHttps = 0x02,
+ kVendorSpecific = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kUpdateAvailable = 0x00,
+ kBusy = 0x01,
+ kNotAvailable = 0x02,
+ kDownloadProtocolNotSupported = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+} // namespace OtaSoftwareUpdateProvider
+
+namespace OtaSoftwareUpdateRequestor {
+
+// Enum for AnnouncementReasonEnum
+enum class AnnouncementReasonEnum : uint8_t
+{
+ kSimpleAnnouncement = 0x00,
+ kUpdateAvailable = 0x01,
+ kUrgentUpdateAvailable = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for ChangeReasonEnum
+enum class ChangeReasonEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kSuccess = 0x01,
+ kFailure = 0x02,
+ kTimeOut = 0x03,
+ kDelayByProvider = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for UpdateStateEnum
+enum class UpdateStateEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kIdle = 0x01,
+ kQuerying = 0x02,
+ kDelayedOnQuery = 0x03,
+ kDownloading = 0x04,
+ kApplying = 0x05,
+ kDelayedOnApply = 0x06,
+ kRollingBack = 0x07,
+ kDelayedOnUserConsent = 0x08,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 9,
+};
+} // namespace OtaSoftwareUpdateRequestor
+
+namespace LocalizationConfiguration {} // namespace LocalizationConfiguration
+
+namespace TimeFormatLocalization {
+
+// Enum for CalendarTypeEnum
+enum class CalendarTypeEnum : uint8_t
+{
+ kBuddhist = 0x00,
+ kChinese = 0x01,
+ kCoptic = 0x02,
+ kEthiopian = 0x03,
+ kGregorian = 0x04,
+ kHebrew = 0x05,
+ kIndian = 0x06,
+ kIslamic = 0x07,
+ kJapanese = 0x08,
+ kKorean = 0x09,
+ kPersian = 0x0A,
+ kTaiwanese = 0x0B,
+ kUseActiveLocale = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 12,
+};
+
+// Enum for HourFormatEnum
+enum class HourFormatEnum : uint8_t
+{
+ k12hr = 0x00,
+ k24hr = 0x01,
+ kUseActiveLocale = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kCalendarFormat = 0x1,
+};
+} // namespace TimeFormatLocalization
+
+namespace UnitLocalization {
+
+// Enum for TempUnitEnum
+enum class TempUnitEnum : uint8_t
+{
+ kFahrenheit = 0x00,
+ kCelsius = 0x01,
+ kKelvin = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTemperatureUnit = 0x1,
+};
+} // namespace UnitLocalization
+
+namespace PowerSourceConfiguration {} // namespace PowerSourceConfiguration
+
+namespace PowerSource {
+
+// Enum for BatApprovedChemistryEnum
+enum class BatApprovedChemistryEnum : uint16_t
+{
+ kUnspecified = 0x00,
+ kAlkaline = 0x01,
+ kLithiumCarbonFluoride = 0x02,
+ kLithiumChromiumOxide = 0x03,
+ kLithiumCopperOxide = 0x04,
+ kLithiumIronDisulfide = 0x05,
+ kLithiumManganeseDioxide = 0x06,
+ kLithiumThionylChloride = 0x07,
+ kMagnesium = 0x08,
+ kMercuryOxide = 0x09,
+ kNickelOxyhydride = 0x0A,
+ kSilverOxide = 0x0B,
+ kZincAir = 0x0C,
+ kZincCarbon = 0x0D,
+ kZincChloride = 0x0E,
+ kZincManganeseDioxide = 0x0F,
+ kLeadAcid = 0x10,
+ kLithiumCobaltOxide = 0x11,
+ kLithiumIon = 0x12,
+ kLithiumIonPolymer = 0x13,
+ kLithiumIronPhosphate = 0x14,
+ kLithiumSulfur = 0x15,
+ kLithiumTitanate = 0x16,
+ kNickelCadmium = 0x17,
+ kNickelHydrogen = 0x18,
+ kNickelIron = 0x19,
+ kNickelMetalHydride = 0x1A,
+ kNickelZinc = 0x1B,
+ kSilverZinc = 0x1C,
+ kSodiumIon = 0x1D,
+ kSodiumSulfur = 0x1E,
+ kZincBromide = 0x1F,
+ kZincCerium = 0x20,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 33,
+};
+
+// Enum for BatChargeFaultEnum
+enum class BatChargeFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kAmbientTooHot = 0x01,
+ kAmbientTooCold = 0x02,
+ kBatteryTooHot = 0x03,
+ kBatteryTooCold = 0x04,
+ kBatteryAbsent = 0x05,
+ kBatteryOverVoltage = 0x06,
+ kBatteryUnderVoltage = 0x07,
+ kChargerOverVoltage = 0x08,
+ kChargerUnderVoltage = 0x09,
+ kSafetyTimeout = 0x0A,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 11,
+};
+
+// Enum for BatChargeLevelEnum
+enum class BatChargeLevelEnum : uint8_t
+{
+ kOk = 0x00,
+ kWarning = 0x01,
+ kCritical = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for BatChargeStateEnum
+enum class BatChargeStateEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kIsCharging = 0x01,
+ kIsAtFullCharge = 0x02,
+ kIsNotCharging = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for BatCommonDesignationEnum
+enum class BatCommonDesignationEnum : uint16_t
+{
+ kUnspecified = 0x00,
+ kAaa = 0x01,
+ kAa = 0x02,
+ kC = 0x03,
+ kD = 0x04,
+ k4v5 = 0x05,
+ k6v0 = 0x06,
+ k9v0 = 0x07,
+ k12aa = 0x08,
+ kAaaa = 0x09,
+ kA = 0x0A,
+ kB = 0x0B,
+ kF = 0x0C,
+ kN = 0x0D,
+ kNo6 = 0x0E,
+ kSubC = 0x0F,
+ kA23 = 0x10,
+ kA27 = 0x11,
+ kBa5800 = 0x12,
+ kDuplex = 0x13,
+ k4sr44 = 0x14,
+ k523 = 0x15,
+ k531 = 0x16,
+ k15v0 = 0x17,
+ k22v5 = 0x18,
+ k30v0 = 0x19,
+ k45v0 = 0x1A,
+ k67v5 = 0x1B,
+ kJ = 0x1C,
+ kCr123a = 0x1D,
+ kCr2 = 0x1E,
+ k2cr5 = 0x1F,
+ kCrP2 = 0x20,
+ kCrV3 = 0x21,
+ kSr41 = 0x22,
+ kSr43 = 0x23,
+ kSr44 = 0x24,
+ kSr45 = 0x25,
+ kSr48 = 0x26,
+ kSr54 = 0x27,
+ kSr55 = 0x28,
+ kSr57 = 0x29,
+ kSr58 = 0x2A,
+ kSr59 = 0x2B,
+ kSr60 = 0x2C,
+ kSr63 = 0x2D,
+ kSr64 = 0x2E,
+ kSr65 = 0x2F,
+ kSr66 = 0x30,
+ kSr67 = 0x31,
+ kSr68 = 0x32,
+ kSr69 = 0x33,
+ kSr516 = 0x34,
+ kSr731 = 0x35,
+ kSr712 = 0x36,
+ kLr932 = 0x37,
+ kA5 = 0x38,
+ kA10 = 0x39,
+ kA13 = 0x3A,
+ kA312 = 0x3B,
+ kA675 = 0x3C,
+ kAc41e = 0x3D,
+ k10180 = 0x3E,
+ k10280 = 0x3F,
+ k10440 = 0x40,
+ k14250 = 0x41,
+ k14430 = 0x42,
+ k14500 = 0x43,
+ k14650 = 0x44,
+ k15270 = 0x45,
+ k16340 = 0x46,
+ kRcr123a = 0x47,
+ k17500 = 0x48,
+ k17670 = 0x49,
+ k18350 = 0x4A,
+ k18500 = 0x4B,
+ k18650 = 0x4C,
+ k19670 = 0x4D,
+ k25500 = 0x4E,
+ k26650 = 0x4F,
+ k32600 = 0x50,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 81,
+};
+
+// Enum for BatFaultEnum
+enum class BatFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kOverTemp = 0x01,
+ kUnderTemp = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for BatReplaceabilityEnum
+enum class BatReplaceabilityEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kNotReplaceable = 0x01,
+ kUserReplaceable = 0x02,
+ kFactoryReplaceable = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for PowerSourceStatusEnum
+enum class PowerSourceStatusEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kActive = 0x01,
+ kStandby = 0x02,
+ kUnavailable = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for WiredCurrentTypeEnum
+enum class WiredCurrentTypeEnum : uint8_t
+{
+ kAc = 0x00,
+ kDc = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for WiredFaultEnum
+enum class WiredFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kOverVoltage = 0x01,
+ kUnderVoltage = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kWired = 0x1,
+ kBattery = 0x2,
+ kRechargeable = 0x4,
+ kReplaceable = 0x8,
+};
+} // namespace PowerSource
+
+namespace GeneralCommissioning {
+
+// Enum for CommissioningErrorEnum
+enum class CommissioningErrorEnum : uint8_t
+{
+ kOk = 0x00,
+ kValueOutsideRange = 0x01,
+ kInvalidAuthentication = 0x02,
+ kNoFailSafe = 0x03,
+ kBusyWithOtherAdmin = 0x04,
+ kRequiredTCNotAccepted = 0x05,
+ kTCAcknowledgementsNotReceived = 0x06,
+ kTCMinVersionNotMet = 0x07,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 8,
+};
+
+// Enum for RegulatoryLocationTypeEnum
+enum class RegulatoryLocationTypeEnum : uint8_t
+{
+ kIndoor = 0x00,
+ kOutdoor = 0x01,
+ kIndoorOutdoor = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTermsAndConditions = 0x1,
+};
+} // namespace GeneralCommissioning
+
+namespace NetworkCommissioning {
+
+// Enum for NetworkCommissioningStatusEnum
+enum class NetworkCommissioningStatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kOutOfRange = 0x01,
+ kBoundsExceeded = 0x02,
+ kNetworkIDNotFound = 0x03,
+ kDuplicateNetworkID = 0x04,
+ kNetworkNotFound = 0x05,
+ kRegulatoryError = 0x06,
+ kAuthFailure = 0x07,
+ kUnsupportedSecurity = 0x08,
+ kOtherConnectionFailure = 0x09,
+ kIPV6Failed = 0x0A,
+ kIPBindFailed = 0x0B,
+ kUnknownError = 0x0C,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 13,
+};
+
+// Enum for WiFiBandEnum
+enum class WiFiBandEnum : uint8_t
+{
+ k2g4 = 0x00,
+ k3g65 = 0x01,
+ k5g = 0x02,
+ k6g = 0x03,
+ k60g = 0x04,
+ k1g = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kWiFiNetworkInterface = 0x1,
+ kThreadNetworkInterface = 0x2,
+ kEthernetNetworkInterface = 0x4,
+ kPerDeviceCredentials = 0x8,
+};
+
+// Bitmap for ThreadCapabilitiesBitmap
+enum class ThreadCapabilitiesBitmap : uint16_t
+{
+ kIsBorderRouterCapable = 0x1,
+ kIsRouterCapable = 0x2,
+ kIsSleepyEndDeviceCapable = 0x4,
+ kIsFullThreadDevice = 0x8,
+ kIsSynchronizedSleepyEndDeviceCapable = 0x10,
+};
+
+// Bitmap for WiFiSecurityBitmap
+enum class WiFiSecurityBitmap : uint8_t
+{
+ kUnencrypted = 0x1,
+ kWep = 0x2,
+ kWpaPersonal = 0x4,
+ kWpa2Personal = 0x8,
+ kWpa3Personal = 0x10,
+ kWpa3MatterPdc = 0x20,
+};
+} // namespace NetworkCommissioning
+
+namespace DiagnosticLogs {
+
+// Enum for IntentEnum
+enum class IntentEnum : uint8_t
+{
+ kEndUserSupport = 0x00,
+ kNetworkDiag = 0x01,
+ kCrashLogs = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kExhausted = 0x01,
+ kNoLogs = 0x02,
+ kBusy = 0x03,
+ kDenied = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for TransferProtocolEnum
+enum class TransferProtocolEnum : uint8_t
+{
+ kResponsePayload = 0x00,
+ kBdx = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+} // namespace DiagnosticLogs
+
+namespace GeneralDiagnostics {
+
+// Enum for BootReasonEnum
+enum class BootReasonEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kPowerOnReboot = 0x01,
+ kBrownOutReset = 0x02,
+ kSoftwareWatchdogReset = 0x03,
+ kHardwareWatchdogReset = 0x04,
+ kSoftwareUpdateCompleted = 0x05,
+ kSoftwareReset = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for HardwareFaultEnum
+enum class HardwareFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kRadio = 0x01,
+ kSensor = 0x02,
+ kResettableOverTemp = 0x03,
+ kNonResettableOverTemp = 0x04,
+ kPowerSource = 0x05,
+ kVisualDisplayFault = 0x06,
+ kAudioOutputFault = 0x07,
+ kUserInterfaceFault = 0x08,
+ kNonVolatileMemoryError = 0x09,
+ kTamperDetected = 0x0A,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 11,
+};
+
+// Enum for InterfaceTypeEnum
+enum class InterfaceTypeEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kWiFi = 0x01,
+ kEthernet = 0x02,
+ kCellular = 0x03,
+ kThread = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for NetworkFaultEnum
+enum class NetworkFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kHardwareFailure = 0x01,
+ kNetworkJammed = 0x02,
+ kConnectionFailed = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for RadioFaultEnum
+enum class RadioFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kWiFiFault = 0x01,
+ kCellularFault = 0x02,
+ kThreadFault = 0x03,
+ kNFCFault = 0x04,
+ kBLEFault = 0x05,
+ kEthernetFault = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kDataModelTest = 0x1,
+};
+} // namespace GeneralDiagnostics
+
+namespace SoftwareDiagnostics {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kWatermarks = 0x1,
+};
+} // namespace SoftwareDiagnostics
+
+namespace ThreadNetworkDiagnostics {
+
+// Enum for ConnectionStatusEnum
+enum class ConnectionStatusEnum : uint8_t
+{
+ kConnected = 0x00,
+ kNotConnected = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for NetworkFaultEnum
+enum class NetworkFaultEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kLinkDown = 0x01,
+ kHardwareFailure = 0x02,
+ kNetworkJammed = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for RoutingRoleEnum
+enum class RoutingRoleEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kUnassigned = 0x01,
+ kSleepyEndDevice = 0x02,
+ kEndDevice = 0x03,
+ kReed = 0x04,
+ kRouter = 0x05,
+ kLeader = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPacketCounts = 0x1,
+ kErrorCounts = 0x2,
+ kMLECounts = 0x4,
+ kMACCounts = 0x8,
+};
+} // namespace ThreadNetworkDiagnostics
+
+namespace WiFiNetworkDiagnostics {
+
+// Enum for AssociationFailureCauseEnum
+enum class AssociationFailureCauseEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kAssociationFailed = 0x01,
+ kAuthenticationFailed = 0x02,
+ kSsidNotFound = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for ConnectionStatusEnum
+enum class ConnectionStatusEnum : uint8_t
+{
+ kConnected = 0x00,
+ kNotConnected = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for SecurityTypeEnum
+enum class SecurityTypeEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kNone = 0x01,
+ kWep = 0x02,
+ kWpa = 0x03,
+ kWpa2 = 0x04,
+ kWpa3 = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Enum for WiFiVersionEnum
+enum class WiFiVersionEnum : uint8_t
+{
+ kA = 0x00,
+ kB = 0x01,
+ kG = 0x02,
+ kN = 0x03,
+ kAc = 0x04,
+ kAx = 0x05,
+ kAh = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPacketCounts = 0x1,
+ kErrorCounts = 0x2,
+};
+} // namespace WiFiNetworkDiagnostics
+
+namespace EthernetNetworkDiagnostics {
+
+// Enum for PHYRateEnum
+enum class PHYRateEnum : uint8_t
+{
+ kRate10M = 0x00,
+ kRate100M = 0x01,
+ kRate1G = 0x02,
+ kRate25g = 0x03,
+ kRate5G = 0x04,
+ kRate10G = 0x05,
+ kRate40G = 0x06,
+ kRate100G = 0x07,
+ kRate200G = 0x08,
+ kRate400G = 0x09,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 10,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPacketCounts = 0x1,
+ kErrorCounts = 0x2,
+};
+} // namespace EthernetNetworkDiagnostics
+
+namespace TimeSynchronization {
+
+// Enum for GranularityEnum
+enum class GranularityEnum : uint8_t
+{
+ kNoTimeGranularity = 0x00,
+ kMinutesGranularity = 0x01,
+ kSecondsGranularity = 0x02,
+ kMillisecondsGranularity = 0x03,
+ kMicrosecondsGranularity = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for StatusCode
+enum class StatusCode : uint8_t
+{
+ kTimeNotAccepted = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for TimeSourceEnum
+enum class TimeSourceEnum : uint8_t
+{
+ kNone = 0x00,
+ kUnknown = 0x01,
+ kAdmin = 0x02,
+ kNodeTimeCluster = 0x03,
+ kNonMatterSNTP = 0x04,
+ kNonMatterNTP = 0x05,
+ kMatterSNTP = 0x06,
+ kMatterNTP = 0x07,
+ kMixedNTP = 0x08,
+ kNonMatterSNTPNTS = 0x09,
+ kNonMatterNTPNTS = 0x0A,
+ kMatterSNTPNTS = 0x0B,
+ kMatterNTPNTS = 0x0C,
+ kMixedNTPNTS = 0x0D,
+ kCloudSource = 0x0E,
+ kPtp = 0x0F,
+ kGnss = 0x10,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 17,
+};
+
+// Enum for TimeZoneDatabaseEnum
+enum class TimeZoneDatabaseEnum : uint8_t
+{
+ kFull = 0x00,
+ kPartial = 0x01,
+ kNone = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTimeZone = 0x1,
+ kNTPClient = 0x2,
+ kNTPServer = 0x4,
+ kTimeSyncClient = 0x8,
+};
+} // namespace TimeSynchronization
+
+namespace BridgedDeviceBasicInformation {
+
+// Enum for ColorEnum
+enum class ColorEnum : uint8_t
+{
+ kBlack = 0x00,
+ kNavy = 0x01,
+ kGreen = 0x02,
+ kTeal = 0x03,
+ kMaroon = 0x04,
+ kPurple = 0x05,
+ kOlive = 0x06,
+ kGray = 0x07,
+ kBlue = 0x08,
+ kLime = 0x09,
+ kAqua = 0x0A,
+ kRed = 0x0B,
+ kFuchsia = 0x0C,
+ kYellow = 0x0D,
+ kWhite = 0x0E,
+ kNickel = 0x0F,
+ kChrome = 0x10,
+ kBrass = 0x11,
+ kCopper = 0x12,
+ kSilver = 0x13,
+ kGold = 0x14,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 21,
+};
+
+// Enum for ProductFinishEnum
+enum class ProductFinishEnum : uint8_t
+{
+ kOther = 0x00,
+ kMatte = 0x01,
+ kSatin = 0x02,
+ kPolished = 0x03,
+ kRugged = 0x04,
+ kFabric = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kBridgedICDSupport = 0x100000,
+};
+} // namespace BridgedDeviceBasicInformation
+
+namespace Switch {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kLatchingSwitch = 0x1,
+ kMomentarySwitch = 0x2,
+ kMomentarySwitchRelease = 0x4,
+ kMomentarySwitchLongPress = 0x8,
+ kMomentarySwitchMultiPress = 0x10,
+ kActionSwitch = 0x20,
+};
+} // namespace Switch
+
+namespace AdministratorCommissioning {
+
+// Enum for CommissioningWindowStatusEnum
+enum class CommissioningWindowStatusEnum : uint8_t
+{
+ kWindowNotOpen = 0x00,
+ kEnhancedWindowOpen = 0x01,
+ kBasicWindowOpen = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for StatusCode
+enum class StatusCode : uint8_t
+{
+ kBusy = 0x02,
+ kPAKEParameterError = 0x03,
+ kWindowNotOpen = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kBasic = 0x1,
+};
+} // namespace AdministratorCommissioning
+
+namespace OperationalCredentials {
+
+// Enum for CertificateChainTypeEnum
+enum class CertificateChainTypeEnum : uint8_t
+{
+ kDACCertificate = 0x01,
+ kPAICertificate = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for NodeOperationalCertStatusEnum
+enum class NodeOperationalCertStatusEnum : uint8_t
+{
+ kOk = 0x00,
+ kInvalidPublicKey = 0x01,
+ kInvalidNodeOpId = 0x02,
+ kInvalidNOC = 0x03,
+ kMissingCsr = 0x04,
+ kTableFull = 0x05,
+ kInvalidAdminSubject = 0x06,
+ kFabricConflict = 0x09,
+ kLabelConflict = 0x0A,
+ kInvalidFabricIndex = 0x0B,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+} // namespace OperationalCredentials
+
+namespace GroupKeyManagement {
+
+// Enum for GroupKeySecurityPolicyEnum
+enum class GroupKeySecurityPolicyEnum : uint8_t
+{
+ kTrustFirst = 0x00,
+ kCacheAndSync = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kCacheAndSync = 0x1,
+};
+} // namespace GroupKeyManagement
+
+namespace FixedLabel {} // namespace FixedLabel
+
+namespace UserLabel {} // namespace UserLabel
+
+namespace ProxyConfiguration {} // namespace ProxyConfiguration
+
+namespace ProxyDiscovery {} // namespace ProxyDiscovery
+
+namespace ProxyValid {} // namespace ProxyValid
+
+namespace BooleanState {} // namespace BooleanState
+
+namespace IcdManagement {
+
+// Enum for ClientTypeEnum
+enum class ClientTypeEnum : uint8_t
+{
+ kPermanent = 0x00,
+ kEphemeral = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for OperatingModeEnum
+enum class OperatingModeEnum : uint8_t
+{
+ kSit = 0x00,
+ kLit = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kCheckInProtocolSupport = 0x1,
+ kUserActiveModeTrigger = 0x2,
+ kLongIdleTimeSupport = 0x4,
+ kDynamicSitLitSupport = 0x8,
+};
+
+// Bitmap for UserActiveModeTriggerBitmap
+enum class UserActiveModeTriggerBitmap : uint32_t
+{
+ kPowerCycle = 0x1,
+ kSettingsMenu = 0x2,
+ kCustomInstruction = 0x4,
+ kDeviceManual = 0x8,
+ kActuateSensor = 0x10,
+ kActuateSensorSeconds = 0x20,
+ kActuateSensorTimes = 0x40,
+ kActuateSensorLightsBlink = 0x80,
+ kResetButton = 0x100,
+ kResetButtonLightsBlink = 0x200,
+ kResetButtonSeconds = 0x400,
+ kResetButtonTimes = 0x800,
+ kSetupButton = 0x1000,
+ kSetupButtonSeconds = 0x2000,
+ kSetupButtonLightsBlink = 0x4000,
+ kSetupButtonTimes = 0x8000,
+ kAppDefinedButton = 0x10000,
+};
+} // namespace IcdManagement
+
+namespace Timer {
+
+// Enum for TimerStatusEnum
+enum class TimerStatusEnum : uint8_t
+{
+ kRunning = 0x00,
+ kPaused = 0x01,
+ kExpired = 0x02,
+ kReady = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kReset = 0x1,
+};
+} // namespace Timer
+
+namespace OvenCavityOperationalState {
+
+// Enum for ErrorStateEnum
+enum class ErrorStateEnum : uint8_t
+{
+ kNoError = 0x00,
+ kUnableToStartOrResume = 0x01,
+ kUnableToCompleteOperation = 0x02,
+ kCommandInvalidInState = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for OperationalStateEnum
+enum class OperationalStateEnum : uint8_t
+{
+ kStopped = 0x00,
+ kRunning = 0x01,
+ kPaused = 0x02,
+ kError = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+} // namespace OvenCavityOperationalState
+
+namespace OvenMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kBake = 0x4000,
+ kConvection = 0x4001,
+ kGrill = 0x4002,
+ kRoast = 0x4003,
+ kClean = 0x4004,
+ kConvectionBake = 0x4005,
+ kConvectionRoast = 0x4006,
+ kWarming = 0x4007,
+ kProofing = 0x4008,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 10,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace OvenMode
+
+namespace LaundryDryerControls {
+
+// Enum for DrynessLevelEnum
+enum class DrynessLevelEnum : uint8_t
+{
+ kLow = 0x00,
+ kNormal = 0x01,
+ kExtra = 0x02,
+ kMax = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+} // namespace LaundryDryerControls
+
+namespace ModeSelect {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace ModeSelect
+
+namespace LaundryWasherMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kNormal = 0x4000,
+ kDelicate = 0x4001,
+ kHeavy = 0x4002,
+ kWhites = 0x4003,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace LaundryWasherMode
+
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kRapidCool = 0x4000,
+ kRapidFreeze = 0x4001,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+
+namespace LaundryWasherControls {
+
+// Enum for NumberOfRinsesEnum
+enum class NumberOfRinsesEnum : uint8_t
+{
+ kNone = 0x00,
+ kNormal = 0x01,
+ kExtra = 0x02,
+ kMax = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kSpin = 0x1,
+ kRinse = 0x2,
+};
+} // namespace LaundryWasherControls
+
+namespace RvcRunMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kIdle = 0x4000,
+ kCleaning = 0x4001,
+ kMapping = 0x4002,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Enum for StatusCode
+enum class StatusCode : uint8_t
+{
+ kStuck = 0x41,
+ kDustBinMissing = 0x42,
+ kDustBinFull = 0x43,
+ kWaterTankEmpty = 0x44,
+ kWaterTankMissing = 0x45,
+ kWaterTankLidOpen = 0x46,
+ kMopCleaningPadMissing = 0x47,
+ kBatteryLow = 0x48,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kDirectModeChange = 0x10000,
+};
+} // namespace RvcRunMode
+
+namespace RvcCleanMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kDeepClean = 0x4000,
+ kVacuum = 0x4001,
+ kMop = 0x4002,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Enum for StatusCode
+enum class StatusCode : uint8_t
+{
+ kCleaningInProgress = 0x40,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kDirectModeChange = 0x10000,
+};
+} // namespace RvcCleanMode
+
+namespace TemperatureControl {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTemperatureNumber = 0x1,
+ kTemperatureLevel = 0x2,
+ kTemperatureStep = 0x4,
+};
+} // namespace TemperatureControl
+
+namespace RefrigeratorAlarm {
+
+// Bitmap for AlarmBitmap
+enum class AlarmBitmap : uint32_t
+{
+ kDoorOpen = 0x1,
+};
+} // namespace RefrigeratorAlarm
+
+namespace DishwasherMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kNormal = 0x4000,
+ kHeavy = 0x4001,
+ kLight = 0x4002,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace DishwasherMode
+
+namespace AirQuality {
+
+// Enum for AirQualityEnum
+enum class AirQualityEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kGood = 0x01,
+ kFair = 0x02,
+ kModerate = 0x03,
+ kPoor = 0x04,
+ kVeryPoor = 0x05,
+ kExtremelyPoor = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kFair = 0x1,
+ kModerate = 0x2,
+ kVeryPoor = 0x4,
+ kExtremelyPoor = 0x8,
+};
+} // namespace AirQuality
+
+namespace SmokeCoAlarm {
+
+// Enum for AlarmStateEnum
+enum class AlarmStateEnum : uint8_t
+{
+ kNormal = 0x00,
+ kWarning = 0x01,
+ kCritical = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for ContaminationStateEnum
+enum class ContaminationStateEnum : uint8_t
+{
+ kNormal = 0x00,
+ kLow = 0x01,
+ kWarning = 0x02,
+ kCritical = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for EndOfServiceEnum
+enum class EndOfServiceEnum : uint8_t
+{
+ kNormal = 0x00,
+ kExpired = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ExpressedStateEnum
+enum class ExpressedStateEnum : uint8_t
+{
+ kNormal = 0x00,
+ kSmokeAlarm = 0x01,
+ kCOAlarm = 0x02,
+ kBatteryAlert = 0x03,
+ kTesting = 0x04,
+ kHardwareFault = 0x05,
+ kEndOfService = 0x06,
+ kInterconnectSmoke = 0x07,
+ kInterconnectCO = 0x08,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 9,
+};
+
+// Enum for MuteStateEnum
+enum class MuteStateEnum : uint8_t
+{
+ kNotMuted = 0x00,
+ kMuted = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for SensitivityEnum
+enum class SensitivityEnum : uint8_t
+{
+ kHigh = 0x00,
+ kStandard = 0x01,
+ kLow = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kSmokeAlarm = 0x1,
+ kCoAlarm = 0x2,
+};
+} // namespace SmokeCoAlarm
+
+namespace DishwasherAlarm {
+
+// Bitmap for AlarmBitmap
+enum class AlarmBitmap : uint32_t
+{
+ kInflowError = 0x1,
+ kDrainError = 0x2,
+ kDoorError = 0x4,
+ kTempTooLow = 0x8,
+ kTempTooHigh = 0x10,
+ kWaterLevelError = 0x20,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kReset = 0x1,
+};
+} // namespace DishwasherAlarm
+
+namespace MicrowaveOvenMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kNormal = 0x4000,
+ kDefrost = 0x4001,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 10,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace MicrowaveOvenMode
+
+namespace MicrowaveOvenControl {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPowerAsNumber = 0x1,
+ kPowerInWatts = 0x2,
+ kPowerNumberLimits = 0x4,
+};
+} // namespace MicrowaveOvenControl
+
+namespace OperationalState {
+
+// Enum for ErrorStateEnum
+enum class ErrorStateEnum : uint8_t
+{
+ kNoError = 0x00,
+ kUnableToStartOrResume = 0x01,
+ kUnableToCompleteOperation = 0x02,
+ kCommandInvalidInState = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for OperationalStateEnum
+enum class OperationalStateEnum : uint8_t
+{
+ kStopped = 0x00,
+ kRunning = 0x01,
+ kPaused = 0x02,
+ kError = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+} // namespace OperationalState
+
+namespace RvcOperationalState {
+
+// Enum for ErrorStateEnum
+enum class ErrorStateEnum : uint8_t
+{
+ kNoError = 0x00,
+ kUnableToStartOrResume = 0x01,
+ kUnableToCompleteOperation = 0x02,
+ kCommandInvalidInState = 0x03,
+ kFailedToFindChargingDock = 0x40,
+ kStuck = 0x41,
+ kDustBinMissing = 0x42,
+ kDustBinFull = 0x43,
+ kWaterTankEmpty = 0x44,
+ kWaterTankMissing = 0x45,
+ kWaterTankLidOpen = 0x46,
+ kMopCleaningPadMissing = 0x47,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Enum for OperationalStateEnum
+enum class OperationalStateEnum : uint8_t
+{
+ kStopped = 0x00,
+ kRunning = 0x01,
+ kPaused = 0x02,
+ kError = 0x03,
+ kSeekingCharger = 0x40,
+ kCharging = 0x41,
+ kDocked = 0x42,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+} // namespace RvcOperationalState
+
+namespace ScenesManagement {
+
+// Bitmap for CopyModeBitmap
+enum class CopyModeBitmap : uint8_t
+{
+ kCopyAllScenes = 0x1,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kSceneNames = 0x1,
+};
+} // namespace ScenesManagement
+
+namespace HepaFilterMonitoring {
+
+using ChangeIndicationEnum = Clusters::detail::ChangeIndicationEnum;
+
+using DegradationDirectionEnum = Clusters::detail::DegradationDirectionEnum;
+
+using ProductIdentifierTypeEnum = Clusters::detail::ProductIdentifierTypeEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kCondition = 0x1,
+ kWarning = 0x2,
+ kReplacementProductList = 0x4,
+};
+} // namespace HepaFilterMonitoring
+
+namespace ActivatedCarbonFilterMonitoring {
+
+using ChangeIndicationEnum = Clusters::detail::ChangeIndicationEnum;
+
+using DegradationDirectionEnum = Clusters::detail::DegradationDirectionEnum;
+
+using ProductIdentifierTypeEnum = Clusters::detail::ProductIdentifierTypeEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kCondition = 0x1,
+ kWarning = 0x2,
+ kReplacementProductList = 0x4,
+};
+} // namespace ActivatedCarbonFilterMonitoring
+
+namespace BooleanStateConfiguration {
+
+// Bitmap for AlarmModeBitmap
+enum class AlarmModeBitmap : uint8_t
+{
+ kVisual = 0x1,
+ kAudible = 0x2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kVisual = 0x1,
+ kAudible = 0x2,
+ kAlarmSuppress = 0x4,
+ kSensitivityLevel = 0x8,
+};
+
+// Bitmap for SensorFaultBitmap
+enum class SensorFaultBitmap : uint16_t
+{
+ kGeneralFault = 0x1,
+};
+} // namespace BooleanStateConfiguration
+
+namespace ValveConfigurationAndControl {
+
+// Enum for StatusCodeEnum
+enum class StatusCodeEnum : uint8_t
+{
+ kFailureDueToFault = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for ValveStateEnum
+enum class ValveStateEnum : uint8_t
+{
+ kClosed = 0x00,
+ kOpen = 0x01,
+ kTransitioning = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTimeSync = 0x1,
+ kLevel = 0x2,
+};
+
+// Bitmap for ValveFaultBitmap
+enum class ValveFaultBitmap : uint16_t
+{
+ kGeneralFault = 0x1,
+ kBlocked = 0x2,
+ kLeaking = 0x4,
+ kNotConnected = 0x8,
+ kShortCircuit = 0x10,
+ kCurrentExceeded = 0x20,
+};
+} // namespace ValveConfigurationAndControl
+
+namespace ElectricalPowerMeasurement {
+
+using MeasurementTypeEnum = Clusters::detail::MeasurementTypeEnum;
+
+// Enum for PowerModeEnum
+enum class PowerModeEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kDc = 0x01,
+ kAc = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kDirectCurrent = 0x1,
+ kAlternatingCurrent = 0x2,
+ kPolyphasePower = 0x4,
+ kHarmonics = 0x8,
+ kPowerQuality = 0x10,
+};
+} // namespace ElectricalPowerMeasurement
+
+namespace ElectricalEnergyMeasurement {
+
+using MeasurementTypeEnum = Clusters::detail::MeasurementTypeEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kImportedEnergy = 0x1,
+ kExportedEnergy = 0x2,
+ kCumulativeEnergy = 0x4,
+ kPeriodicEnergy = 0x8,
+};
+} // namespace ElectricalEnergyMeasurement
+
+namespace WaterHeaterManagement {
+
+// Enum for BoostStateEnum
+enum class BoostStateEnum : uint8_t
+{
+ kInactive = 0x00,
+ kActive = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kEnergyManagement = 0x1,
+ kTankPercent = 0x2,
+};
+
+// Bitmap for WaterHeaterHeatSourceBitmap
+enum class WaterHeaterHeatSourceBitmap : uint8_t
+{
+ kImmersionElement1 = 0x1,
+ kImmersionElement2 = 0x2,
+ kHeatPump = 0x4,
+ kBoiler = 0x8,
+ kOther = 0x10,
+};
+} // namespace WaterHeaterManagement
+
+namespace DemandResponseLoadControl {
+
+// Enum for CriticalityLevelEnum
+enum class CriticalityLevelEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kGreen = 0x01,
+ kLevel1 = 0x02,
+ kLevel2 = 0x03,
+ kLevel3 = 0x04,
+ kLevel4 = 0x05,
+ kLevel5 = 0x06,
+ kEmergency = 0x07,
+ kPlannedOutage = 0x08,
+ kServiceDisconnect = 0x09,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 10,
+};
+
+// Enum for HeatingSourceEnum
+enum class HeatingSourceEnum : uint8_t
+{
+ kAny = 0x00,
+ kElectric = 0x01,
+ kNonElectric = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for LoadControlEventChangeSourceEnum
+enum class LoadControlEventChangeSourceEnum : uint8_t
+{
+ kAutomatic = 0x00,
+ kUserAction = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for LoadControlEventStatusEnum
+enum class LoadControlEventStatusEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kReceived = 0x01,
+ kInProgress = 0x02,
+ kCompleted = 0x03,
+ kOptedOut = 0x04,
+ kOptedIn = 0x05,
+ kCanceled = 0x06,
+ kSuperseded = 0x07,
+ kPartialOptedOut = 0x08,
+ kPartialOptedIn = 0x09,
+ kNoParticipation = 0x0A,
+ kUnavailable = 0x0B,
+ kFailed = 0x0C,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 13,
+};
+
+// Bitmap for CancelControlBitmap
+enum class CancelControlBitmap : uint16_t
+{
+ kRandomEnd = 0x1,
+};
+
+// Bitmap for DeviceClassBitmap
+enum class DeviceClassBitmap : uint32_t
+{
+ kHvac = 0x1,
+ kStripHeater = 0x2,
+ kWaterHeater = 0x4,
+ kPoolPump = 0x8,
+ kSmartAppliance = 0x10,
+ kIrrigationPump = 0x20,
+ kCommercialLoad = 0x40,
+ kResidentialLoad = 0x80,
+ kExteriorLighting = 0x100,
+ kInteriorLighting = 0x200,
+ kEv = 0x400,
+ kGenerationSystem = 0x800,
+ kSmartInverter = 0x1000,
+ kEvse = 0x2000,
+ kResu = 0x4000,
+ kEms = 0x8000,
+ kSem = 0x10000,
+};
+
+// Bitmap for EventControlBitmap
+enum class EventControlBitmap : uint16_t
+{
+ kRandomStart = 0x1,
+};
+
+// Bitmap for EventTransitionControlBitmap
+enum class EventTransitionControlBitmap : uint16_t
+{
+ kRandomDuration = 0x1,
+ kIgnoreOptOut = 0x2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kEnrollmentGroups = 0x1,
+ kTemperatureOffset = 0x2,
+ kTemperatureSetpoint = 0x4,
+ kLoadAdjustment = 0x8,
+ kDutyCycle = 0x10,
+ kPowerSavings = 0x20,
+ kHeatingSource = 0x40,
+};
+} // namespace DemandResponseLoadControl
+
+namespace Messages {
+
+// Enum for FutureMessagePreferenceEnum
+enum class FutureMessagePreferenceEnum : uint8_t
+{
+ kAllowed = 0x00,
+ kIncreased = 0x01,
+ kReduced = 0x02,
+ kDisallowed = 0x03,
+ kBanned = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for MessagePriorityEnum
+enum class MessagePriorityEnum : uint8_t
+{
+ kLow = 0x00,
+ kMedium = 0x01,
+ kHigh = 0x02,
+ kCritical = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kReceivedConfirmation = 0x1,
+ kConfirmationResponse = 0x2,
+ kConfirmationReply = 0x4,
+ kProtectedMessages = 0x8,
+};
+
+// Bitmap for MessageControlBitmap
+enum class MessageControlBitmap : uint8_t
+{
+ kConfirmationRequired = 0x1,
+ kResponseRequired = 0x2,
+ kReplyMessage = 0x4,
+ kMessageConfirmed = 0x8,
+ kMessageProtected = 0x10,
+};
+} // namespace Messages
+
+namespace DeviceEnergyManagement {
+
+// Enum for AdjustmentCauseEnum
+enum class AdjustmentCauseEnum : uint8_t
+{
+ kLocalOptimization = 0x00,
+ kGridOptimization = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for CauseEnum
+enum class CauseEnum : uint8_t
+{
+ kNormalCompletion = 0x00,
+ kOffline = 0x01,
+ kFault = 0x02,
+ kUserOptOut = 0x03,
+ kCancelled = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for CostTypeEnum
+enum class CostTypeEnum : uint8_t
+{
+ kFinancial = 0x00,
+ kGHGEmissions = 0x01,
+ kComfort = 0x02,
+ kTemperature = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for ESAStateEnum
+enum class ESAStateEnum : uint8_t
+{
+ kOffline = 0x00,
+ kOnline = 0x01,
+ kFault = 0x02,
+ kPowerAdjustActive = 0x03,
+ kPaused = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for ESATypeEnum
+enum class ESATypeEnum : uint8_t
+{
+ kEvse = 0x00,
+ kSpaceHeating = 0x01,
+ kWaterHeating = 0x02,
+ kSpaceCooling = 0x03,
+ kSpaceHeatingCooling = 0x04,
+ kBatteryStorage = 0x05,
+ kSolarPV = 0x06,
+ kFridgeFreezer = 0x07,
+ kWashingMachine = 0x08,
+ kDishwasher = 0x09,
+ kCooking = 0x0A,
+ kHomeWaterPump = 0x0B,
+ kIrrigationWaterPump = 0x0C,
+ kPoolPump = 0x0D,
+ kOther = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 14,
+};
+
+// Enum for ForecastUpdateReasonEnum
+enum class ForecastUpdateReasonEnum : uint8_t
+{
+ kInternalOptimization = 0x00,
+ kLocalOptimization = 0x01,
+ kGridOptimization = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for OptOutStateEnum
+enum class OptOutStateEnum : uint8_t
+{
+ kNoOptOut = 0x00,
+ kLocalOptOut = 0x01,
+ kGridOptOut = 0x02,
+ kOptOut = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for PowerAdjustReasonEnum
+enum class PowerAdjustReasonEnum : uint8_t
+{
+ kNoAdjustment = 0x00,
+ kLocalOptimizationAdjustment = 0x01,
+ kGridOptimizationAdjustment = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPowerAdjustment = 0x1,
+ kPowerForecastReporting = 0x2,
+ kStateForecastReporting = 0x4,
+ kStartTimeAdjustment = 0x8,
+ kPausable = 0x10,
+ kForecastAdjustment = 0x20,
+ kConstraintBasedAdjustment = 0x40,
+};
+} // namespace DeviceEnergyManagement
+
+namespace EnergyEvse {
+
+// Enum for EnergyTransferStoppedReasonEnum
+enum class EnergyTransferStoppedReasonEnum : uint8_t
+{
+ kEVStopped = 0x00,
+ kEVSEStopped = 0x01,
+ kOther = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for FaultStateEnum
+enum class FaultStateEnum : uint8_t
+{
+ kNoError = 0x00,
+ kMeterFailure = 0x01,
+ kOverVoltage = 0x02,
+ kUnderVoltage = 0x03,
+ kOverCurrent = 0x04,
+ kContactWetFailure = 0x05,
+ kContactDryFailure = 0x06,
+ kGroundFault = 0x07,
+ kPowerLoss = 0x08,
+ kPowerQuality = 0x09,
+ kPilotShortCircuit = 0x0A,
+ kEmergencyStop = 0x0B,
+ kEVDisconnected = 0x0C,
+ kWrongPowerSupply = 0x0D,
+ kLiveNeutralSwap = 0x0E,
+ kOverTemperature = 0x0F,
+ kOther = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 16,
+};
+
+// Enum for StateEnum
+enum class StateEnum : uint8_t
+{
+ kNotPluggedIn = 0x00,
+ kPluggedInNoDemand = 0x01,
+ kPluggedInDemand = 0x02,
+ kPluggedInCharging = 0x03,
+ kPluggedInDischarging = 0x04,
+ kSessionEnding = 0x05,
+ kFault = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for SupplyStateEnum
+enum class SupplyStateEnum : uint8_t
+{
+ kDisabled = 0x00,
+ kChargingEnabled = 0x01,
+ kDischargingEnabled = 0x02,
+ kDisabledError = 0x03,
+ kDisabledDiagnostics = 0x04,
+ kEnabled = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kChargingPreferences = 0x1,
+ kSoCReporting = 0x2,
+ kPlugAndCharge = 0x4,
+ kRfid = 0x8,
+ kV2x = 0x10,
+};
+
+// Bitmap for TargetDayOfWeekBitmap
+enum class TargetDayOfWeekBitmap : uint8_t
+{
+ kSunday = 0x1,
+ kMonday = 0x2,
+ kTuesday = 0x4,
+ kWednesday = 0x8,
+ kThursday = 0x10,
+ kFriday = 0x20,
+ kSaturday = 0x40,
+};
+} // namespace EnergyEvse
+
+namespace EnergyPreference {
+
+// Enum for EnergyPriorityEnum
+enum class EnergyPriorityEnum : uint8_t
+{
+ kComfort = 0x00,
+ kSpeed = 0x01,
+ kEfficiency = 0x02,
+ kWaterConsumption = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kEnergyBalance = 0x1,
+ kLowPowerModeSensitivity = 0x2,
+};
+} // namespace EnergyPreference
+
+namespace PowerTopology {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNodeTopology = 0x1,
+ kTreeTopology = 0x2,
+ kSetTopology = 0x4,
+ kDynamicPowerFlow = 0x8,
+};
+} // namespace PowerTopology
+
+namespace EnergyEvseMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kManual = 0x4000,
+ kTimeOfUse = 0x4001,
+ kSolarCharging = 0x4002,
+ kV2x = 0x4003,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace EnergyEvseMode
+
+namespace WaterHeaterMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kOff = 0x4000,
+ kManual = 0x4001,
+ kTimed = 0x4002,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace WaterHeaterMode
+
+namespace DeviceEnergyManagementMode {
+
+// Enum for ModeTag
+enum class ModeTag : uint16_t
+{
+ kAuto = 0x00,
+ kQuick = 0x01,
+ kQuiet = 0x02,
+ kLowNoise = 0x03,
+ kLowEnergy = 0x04,
+ kVacation = 0x05,
+ kMin = 0x06,
+ kMax = 0x07,
+ kNight = 0x08,
+ kDay = 0x09,
+ kNoOptimization = 0x4000,
+ kDeviceOptimization = 0x4001,
+ kLocalOptimization = 0x4002,
+ kGridOptimization = 0x4003,
+ // kUnknownEnumValue intentionally not defined. This enum never goes
+ // through DataModel::Decode, likely because it is a part of a derived
+ // cluster. As a result having kUnknownEnumValue in this enum is error
+ // prone, and was removed. See
+ // src/app/common/templates/config-data.yaml.
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOnOff = 0x1,
+};
+} // namespace DeviceEnergyManagementMode
+
+namespace DoorLock {
+
+// Enum for AlarmCodeEnum
+enum class AlarmCodeEnum : uint8_t
+{
+ kLockJammed = 0x00,
+ kLockFactoryReset = 0x01,
+ kLockRadioPowerCycled = 0x03,
+ kWrongCodeEntryLimit = 0x04,
+ kFrontEsceutcheonRemoved = 0x05,
+ kDoorForcedOpen = 0x06,
+ kDoorAjar = 0x07,
+ kForcedUser = 0x08,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for CredentialRuleEnum
+enum class CredentialRuleEnum : uint8_t
+{
+ kSingle = 0x00,
+ kDual = 0x01,
+ kTri = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for CredentialTypeEnum
+enum class CredentialTypeEnum : uint8_t
+{
+ kProgrammingPIN = 0x00,
+ kPin = 0x01,
+ kRfid = 0x02,
+ kFingerprint = 0x03,
+ kFingerVein = 0x04,
+ kFace = 0x05,
+ kAliroCredentialIssuerKey = 0x06,
+ kAliroEvictableEndpointKey = 0x07,
+ kAliroNonEvictableEndpointKey = 0x08,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 9,
+};
+
+// Enum for DataOperationTypeEnum
+enum class DataOperationTypeEnum : uint8_t
+{
+ kAdd = 0x00,
+ kClear = 0x01,
+ kModify = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for DlLockState
+enum class DlLockState : uint8_t
+{
+ kNotFullyLocked = 0x00,
+ kLocked = 0x01,
+ kUnlocked = 0x02,
+ kUnlatched = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for DlLockType
+enum class DlLockType : uint8_t
+{
+ kDeadBolt = 0x00,
+ kMagnetic = 0x01,
+ kOther = 0x02,
+ kMortise = 0x03,
+ kRim = 0x04,
+ kLatchBolt = 0x05,
+ kCylindricalLock = 0x06,
+ kTubularLock = 0x07,
+ kInterconnectedLock = 0x08,
+ kDeadLatch = 0x09,
+ kDoorFurniture = 0x0A,
+ kEurocylinder = 0x0B,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 12,
+};
+
+// Enum for DlStatus
+enum class DlStatus : uint8_t
+{
+ kSuccess = 0x00,
+ kFailure = 0x01,
+ kDuplicate = 0x02,
+ kOccupied = 0x03,
+ kInvalidField = 0x85,
+ kResourceExhausted = 0x89,
+ kNotFound = 0x8B,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for DoorLockOperationEventCode
+enum class DoorLockOperationEventCode : uint8_t
+{
+ kUnknownOrMfgSpecific = 0x00,
+ kLock = 0x01,
+ kUnlock = 0x02,
+ kLockInvalidPinOrId = 0x03,
+ kLockInvalidSchedule = 0x04,
+ kUnlockInvalidPinOrId = 0x05,
+ kUnlockInvalidSchedule = 0x06,
+ kOneTouchLock = 0x07,
+ kKeyLock = 0x08,
+ kKeyUnlock = 0x09,
+ kAutoLock = 0x0A,
+ kScheduleLock = 0x0B,
+ kScheduleUnlock = 0x0C,
+ kManualLock = 0x0D,
+ kManualUnlock = 0x0E,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 15,
+};
+
+// Enum for DoorLockProgrammingEventCode
+enum class DoorLockProgrammingEventCode : uint8_t
+{
+ kUnknownOrMfgSpecific = 0x00,
+ kMasterCodeChanged = 0x01,
+ kPinAdded = 0x02,
+ kPinDeleted = 0x03,
+ kPinChanged = 0x04,
+ kIdAdded = 0x05,
+ kIdDeleted = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for DoorLockSetPinOrIdStatus
+enum class DoorLockSetPinOrIdStatus : uint8_t
+{
+ kSuccess = 0x00,
+ kGeneralFailure = 0x01,
+ kMemoryFull = 0x02,
+ kDuplicateCodeError = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for DoorLockUserStatus
+enum class DoorLockUserStatus : uint8_t
+{
+ kAvailable = 0x00,
+ kOccupiedEnabled = 0x01,
+ kOccupiedDisabled = 0x03,
+ kNotSupported = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for DoorLockUserType
+enum class DoorLockUserType : uint8_t
+{
+ kUnrestricted = 0x00,
+ kYearDayScheduleUser = 0x01,
+ kWeekDayScheduleUser = 0x02,
+ kMasterUser = 0x03,
+ kNonAccessUser = 0x04,
+ kNotSupported = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for DoorStateEnum
+enum class DoorStateEnum : uint8_t
+{
+ kDoorOpen = 0x00,
+ kDoorClosed = 0x01,
+ kDoorJammed = 0x02,
+ kDoorForcedOpen = 0x03,
+ kDoorUnspecifiedError = 0x04,
+ kDoorAjar = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Enum for LockDataTypeEnum
+enum class LockDataTypeEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kProgrammingCode = 0x01,
+ kUserIndex = 0x02,
+ kWeekDaySchedule = 0x03,
+ kYearDaySchedule = 0x04,
+ kHolidaySchedule = 0x05,
+ kPin = 0x06,
+ kRfid = 0x07,
+ kFingerprint = 0x08,
+ kFingerVein = 0x09,
+ kFace = 0x0A,
+ kAliroCredentialIssuerKey = 0x0B,
+ kAliroEvictableEndpointKey = 0x0C,
+ kAliroNonEvictableEndpointKey = 0x0D,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 14,
+};
+
+// Enum for LockOperationTypeEnum
+enum class LockOperationTypeEnum : uint8_t
+{
+ kLock = 0x00,
+ kUnlock = 0x01,
+ kNonAccessUserEvent = 0x02,
+ kForcedUserEvent = 0x03,
+ kUnlatch = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for OperatingModeEnum
+enum class OperatingModeEnum : uint8_t
+{
+ kNormal = 0x00,
+ kVacation = 0x01,
+ kPrivacy = 0x02,
+ kNoRemoteLockUnlock = 0x03,
+ kPassage = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for OperationErrorEnum
+enum class OperationErrorEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kInvalidCredential = 0x01,
+ kDisabledUserDenied = 0x02,
+ kRestricted = 0x03,
+ kInsufficientBattery = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for OperationSourceEnum
+enum class OperationSourceEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kManual = 0x01,
+ kProprietaryRemote = 0x02,
+ kKeypad = 0x03,
+ kAuto = 0x04,
+ kButton = 0x05,
+ kSchedule = 0x06,
+ kRemote = 0x07,
+ kRfid = 0x08,
+ kBiometric = 0x09,
+ kAliro = 0x0A,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 11,
+};
+
+// Enum for UserStatusEnum
+enum class UserStatusEnum : uint8_t
+{
+ kAvailable = 0x00,
+ kOccupiedEnabled = 0x01,
+ kOccupiedDisabled = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for UserTypeEnum
+enum class UserTypeEnum : uint8_t
+{
+ kUnrestrictedUser = 0x00,
+ kYearDayScheduleUser = 0x01,
+ kWeekDayScheduleUser = 0x02,
+ kProgrammingUser = 0x03,
+ kNonAccessUser = 0x04,
+ kForcedUser = 0x05,
+ kDisposableUser = 0x06,
+ kExpiringUser = 0x07,
+ kScheduleRestrictedUser = 0x08,
+ kRemoteOnlyUser = 0x09,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 10,
+};
+
+// Bitmap for DaysMaskMap
+enum class DaysMaskMap : uint8_t
+{
+ kSunday = 0x1,
+ kMonday = 0x2,
+ kTuesday = 0x4,
+ kWednesday = 0x8,
+ kThursday = 0x10,
+ kFriday = 0x20,
+ kSaturday = 0x40,
+};
+
+// Bitmap for DlCredentialRuleMask
+enum class DlCredentialRuleMask : uint8_t
+{
+ kSingle = 0x1,
+ kDual = 0x2,
+ kTri = 0x4,
+};
+
+// Bitmap for DlCredentialRulesSupport
+enum class DlCredentialRulesSupport : uint8_t
+{
+ kSingle = 0x1,
+ kDual = 0x2,
+ kTri = 0x4,
+};
+
+// Bitmap for DlDefaultConfigurationRegister
+enum class DlDefaultConfigurationRegister : uint16_t
+{
+ kEnableLocalProgrammingEnabled = 0x1,
+ kKeypadInterfaceDefaultAccessEnabled = 0x2,
+ kRemoteInterfaceDefaultAccessIsEnabled = 0x4,
+ kSoundEnabled = 0x20,
+ kAutoRelockTimeSet = 0x40,
+ kLEDSettingsSet = 0x80,
+};
+
+// Bitmap for DlKeypadOperationEventMask
+enum class DlKeypadOperationEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kLock = 0x2,
+ kUnlock = 0x4,
+ kLockInvalidPIN = 0x8,
+ kLockInvalidSchedule = 0x10,
+ kUnlockInvalidCode = 0x20,
+ kUnlockInvalidSchedule = 0x40,
+ kNonAccessUserOpEvent = 0x80,
+};
+
+// Bitmap for DlKeypadProgrammingEventMask
+enum class DlKeypadProgrammingEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kProgrammingPINChanged = 0x2,
+ kPINAdded = 0x4,
+ kPINCleared = 0x8,
+ kPINChanged = 0x10,
+};
+
+// Bitmap for DlLocalProgrammingFeatures
+enum class DlLocalProgrammingFeatures : uint8_t
+{
+ kAddUsersCredentialsSchedulesLocally = 0x1,
+ kModifyUsersCredentialsSchedulesLocally = 0x2,
+ kClearUsersCredentialsSchedulesLocally = 0x4,
+ kAdjustLockSettingsLocally = 0x8,
+};
+
+// Bitmap for DlManualOperationEventMask
+enum class DlManualOperationEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kThumbturnLock = 0x2,
+ kThumbturnUnlock = 0x4,
+ kOneTouchLock = 0x8,
+ kKeyLock = 0x10,
+ kKeyUnlock = 0x20,
+ kAutoLock = 0x40,
+ kScheduleLock = 0x80,
+ kScheduleUnlock = 0x100,
+ kManualLock = 0x200,
+ kManualUnlock = 0x400,
+};
+
+// Bitmap for DlRFIDOperationEventMask
+enum class DlRFIDOperationEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kLock = 0x2,
+ kUnlock = 0x4,
+ kLockInvalidRFID = 0x8,
+ kLockInvalidSchedule = 0x10,
+ kUnlockInvalidRFID = 0x20,
+ kUnlockInvalidSchedule = 0x40,
+};
+
+// Bitmap for DlRFIDProgrammingEventMask
+enum class DlRFIDProgrammingEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kRFIDCodeAdded = 0x20,
+ kRFIDCodeCleared = 0x40,
+};
+
+// Bitmap for DlRemoteOperationEventMask
+enum class DlRemoteOperationEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kLock = 0x2,
+ kUnlock = 0x4,
+ kLockInvalidCode = 0x8,
+ kLockInvalidSchedule = 0x10,
+ kUnlockInvalidCode = 0x20,
+ kUnlockInvalidSchedule = 0x40,
+};
+
+// Bitmap for DlRemoteProgrammingEventMask
+enum class DlRemoteProgrammingEventMask : uint16_t
+{
+ kUnknown = 0x1,
+ kProgrammingPINChanged = 0x2,
+ kPINAdded = 0x4,
+ kPINCleared = 0x8,
+ kPINChanged = 0x10,
+ kRFIDCodeAdded = 0x20,
+ kRFIDCodeCleared = 0x40,
+};
+
+// Bitmap for DlSupportedOperatingModes
+enum class DlSupportedOperatingModes : uint16_t
+{
+ kNormal = 0x1,
+ kVacation = 0x2,
+ kPrivacy = 0x4,
+ kNoRemoteLockUnlock = 0x8,
+ kPassage = 0x10,
+};
+
+// Bitmap for DoorLockDayOfWeek
+enum class DoorLockDayOfWeek : uint8_t
+{
+ kSunday = 0x1,
+ kMonday = 0x2,
+ kTuesday = 0x4,
+ kWednesday = 0x8,
+ kThursday = 0x10,
+ kFriday = 0x20,
+ kSaturday = 0x40,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPinCredential = 0x1,
+ kRfidCredential = 0x2,
+ kFingerCredentials = 0x4,
+ kLogging = 0x8,
+ kWeekDayAccessSchedules = 0x10,
+ kDoorPositionSensor = 0x20,
+ kFaceCredentials = 0x40,
+ kCredentialsOverTheAirAccess = 0x80,
+ kUser = 0x100,
+ kNotification = 0x200,
+ kYearDayAccessSchedules = 0x400,
+ kHolidaySchedules = 0x800,
+ kUnbolt = 0x1000,
+ kAliroProvisioning = 0x2000,
+ kAliroBLEUWB = 0x4000,
+};
+} // namespace DoorLock
+
+namespace WindowCovering {
+
+// Enum for EndProductType
+enum class EndProductType : uint8_t
+{
+ kRollerShade = 0x00,
+ kRomanShade = 0x01,
+ kBalloonShade = 0x02,
+ kWovenWood = 0x03,
+ kPleatedShade = 0x04,
+ kCellularShade = 0x05,
+ kLayeredShade = 0x06,
+ kLayeredShade2D = 0x07,
+ kSheerShade = 0x08,
+ kTiltOnlyInteriorBlind = 0x09,
+ kInteriorBlind = 0x0A,
+ kVerticalBlindStripCurtain = 0x0B,
+ kInteriorVenetianBlind = 0x0C,
+ kExteriorVenetianBlind = 0x0D,
+ kLateralLeftCurtain = 0x0E,
+ kLateralRightCurtain = 0x0F,
+ kCentralCurtain = 0x10,
+ kRollerShutter = 0x11,
+ kExteriorVerticalScreen = 0x12,
+ kAwningTerracePatio = 0x13,
+ kAwningVerticalScreen = 0x14,
+ kTiltOnlyPergola = 0x15,
+ kSwingingShutter = 0x16,
+ kSlidingShutter = 0x17,
+ kUnknown = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 24,
+};
+
+// Enum for Type
+enum class Type : uint8_t
+{
+ kRollerShade = 0x00,
+ kRollerShade2Motor = 0x01,
+ kRollerShadeExterior = 0x02,
+ kRollerShadeExterior2Motor = 0x03,
+ kDrapery = 0x04,
+ kAwning = 0x05,
+ kShutter = 0x06,
+ kTiltBlindTiltOnly = 0x07,
+ kTiltBlindLiftAndTilt = 0x08,
+ kProjectorScreen = 0x09,
+ kUnknown = 0xFF,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 10,
+};
+
+// Bitmap for ConfigStatus
+enum class ConfigStatus : uint8_t
+{
+ kOperational = 0x1,
+ kOnlineReserved = 0x2,
+ kLiftMovementReversed = 0x4,
+ kLiftPositionAware = 0x8,
+ kTiltPositionAware = 0x10,
+ kLiftEncoderControlled = 0x20,
+ kTiltEncoderControlled = 0x40,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kLift = 0x1,
+ kTilt = 0x2,
+ kPositionAwareLift = 0x4,
+ kAbsolutePosition = 0x8,
+ kPositionAwareTilt = 0x10,
+};
+
+// Bitmap for Mode
+enum class Mode : uint8_t
+{
+ kMotorDirectionReversed = 0x1,
+ kCalibrationMode = 0x2,
+ kMaintenanceMode = 0x4,
+ kLedFeedback = 0x8,
+};
+
+// Bitmap for OperationalStatus
+enum class OperationalStatus : uint8_t
+{
+ kGlobal = 0x3,
+ kLift = 0xC,
+ kTilt = 0x30,
+};
+
+// Bitmap for SafetyStatus
+enum class SafetyStatus : uint16_t
+{
+ kRemoteLockout = 0x1,
+ kTamperDetection = 0x2,
+ kFailedCommunication = 0x4,
+ kPositionFailure = 0x8,
+ kThermalProtection = 0x10,
+ kObstacleDetected = 0x20,
+ kPower = 0x40,
+ kStopInput = 0x80,
+ kMotorJammed = 0x100,
+ kHardwareFailure = 0x200,
+ kManualOperation = 0x400,
+ kProtection = 0x800,
+};
+} // namespace WindowCovering
+
+namespace ServiceArea {
+
+// Enum for OperationalStatusEnum
+enum class OperationalStatusEnum : uint8_t
+{
+ kPending = 0x00,
+ kOperating = 0x01,
+ kSkipped = 0x02,
+ kCompleted = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for SelectAreasStatus
+enum class SelectAreasStatus : uint8_t
+{
+ kSuccess = 0x00,
+ kUnsupportedArea = 0x01,
+ kInvalidInMode = 0x02,
+ kInvalidSet = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for SkipAreaStatus
+enum class SkipAreaStatus : uint8_t
+{
+ kSuccess = 0x00,
+ kInvalidAreaList = 0x01,
+ kInvalidInMode = 0x02,
+ kInvalidSkippedArea = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kSelectWhileRunning = 0x1,
+ kProgressReporting = 0x2,
+ kMaps = 0x4,
+};
+} // namespace ServiceArea
+
+namespace PumpConfigurationAndControl {
+
+// Enum for ControlModeEnum
+enum class ControlModeEnum : uint8_t
+{
+ kConstantSpeed = 0x00,
+ kConstantPressure = 0x01,
+ kProportionalPressure = 0x02,
+ kConstantFlow = 0x03,
+ kConstantTemperature = 0x05,
+ kAutomatic = 0x07,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for OperationModeEnum
+enum class OperationModeEnum : uint8_t
+{
+ kNormal = 0x00,
+ kMinimum = 0x01,
+ kMaximum = 0x02,
+ kLocal = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kConstantPressure = 0x1,
+ kCompensatedPressure = 0x2,
+ kConstantFlow = 0x4,
+ kConstantSpeed = 0x8,
+ kConstantTemperature = 0x10,
+ kAutomatic = 0x20,
+ kLocalOperation = 0x40,
+};
+
+// Bitmap for PumpStatusBitmap
+enum class PumpStatusBitmap : uint16_t
+{
+ kDeviceFault = 0x1,
+ kSupplyFault = 0x2,
+ kSpeedLow = 0x4,
+ kSpeedHigh = 0x8,
+ kLocalOverride = 0x10,
+ kRunning = 0x20,
+ kRemotePressure = 0x40,
+ kRemoteFlow = 0x80,
+ kRemoteTemperature = 0x100,
+};
+} // namespace PumpConfigurationAndControl
+
+namespace Thermostat {
+
+// Enum for ACCapacityFormatEnum
+enum class ACCapacityFormatEnum : uint8_t
+{
+ kBTUh = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Enum for ACCompressorTypeEnum
+enum class ACCompressorTypeEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kT1 = 0x01,
+ kT2 = 0x02,
+ kT3 = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for ACLouverPositionEnum
+enum class ACLouverPositionEnum : uint8_t
+{
+ kClosed = 0x01,
+ kOpen = 0x02,
+ kQuarter = 0x03,
+ kHalf = 0x04,
+ kThreeQuarters = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for ACRefrigerantTypeEnum
+enum class ACRefrigerantTypeEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kR22 = 0x01,
+ kR410a = 0x02,
+ kR407c = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for ACTypeEnum
+enum class ACTypeEnum : uint8_t
+{
+ kUnknown = 0x00,
+ kCoolingFixed = 0x01,
+ kHeatPumpFixed = 0x02,
+ kCoolingInverter = 0x03,
+ kHeatPumpInverter = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for ControlSequenceOfOperationEnum
+enum class ControlSequenceOfOperationEnum : uint8_t
+{
+ kCoolingOnly = 0x00,
+ kCoolingWithReheat = 0x01,
+ kHeatingOnly = 0x02,
+ kHeatingWithReheat = 0x03,
+ kCoolingAndHeating = 0x04,
+ kCoolingAndHeatingWithReheat = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Enum for PresetScenarioEnum
+enum class PresetScenarioEnum : uint8_t
+{
+ kOccupied = 0x01,
+ kUnoccupied = 0x02,
+ kSleep = 0x03,
+ kWake = 0x04,
+ kVacation = 0x05,
+ kGoingToSleep = 0x06,
+ kUserDefined = 0xFE,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for SetpointChangeSourceEnum
+enum class SetpointChangeSourceEnum : uint8_t
+{
+ kManual = 0x00,
+ kSchedule = 0x01,
+ kExternal = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for SetpointRaiseLowerModeEnum
+enum class SetpointRaiseLowerModeEnum : uint8_t
+{
+ kHeat = 0x00,
+ kCool = 0x01,
+ kBoth = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for StartOfWeekEnum
+enum class StartOfWeekEnum : uint8_t
+{
+ kSunday = 0x00,
+ kMonday = 0x01,
+ kTuesday = 0x02,
+ kWednesday = 0x03,
+ kThursday = 0x04,
+ kFriday = 0x05,
+ kSaturday = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for SystemModeEnum
+enum class SystemModeEnum : uint8_t
+{
+ kOff = 0x00,
+ kAuto = 0x01,
+ kCool = 0x03,
+ kHeat = 0x04,
+ kEmergencyHeat = 0x05,
+ kPrecooling = 0x06,
+ kFanOnly = 0x07,
+ kDry = 0x08,
+ kSleep = 0x09,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for TemperatureSetpointHoldEnum
+enum class TemperatureSetpointHoldEnum : uint8_t
+{
+ kSetpointHoldOff = 0x00,
+ kSetpointHoldOn = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ThermostatRunningModeEnum
+enum class ThermostatRunningModeEnum : uint8_t
+{
+ kOff = 0x00,
+ kCool = 0x03,
+ kHeat = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Bitmap for ACErrorCodeBitmap
+enum class ACErrorCodeBitmap : uint32_t
+{
+ kCompressorFail = 0x1,
+ kRoomSensorFail = 0x2,
+ kOutdoorSensorFail = 0x4,
+ kCoilSensorFail = 0x8,
+ kFanFail = 0x10,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kHeating = 0x1,
+ kCooling = 0x2,
+ kOccupancy = 0x4,
+ kScheduleConfiguration = 0x8,
+ kSetback = 0x10,
+ kAutoMode = 0x20,
+ kLocalTemperatureNotExposed = 0x40,
+ kMatterScheduleConfiguration = 0x80,
+ kPresets = 0x100,
+};
+
+// Bitmap for HVACSystemTypeBitmap
+enum class HVACSystemTypeBitmap : uint8_t
+{
+ kCoolingStage = 0x3,
+ kHeatingStage = 0xC,
+ kHeatingIsHeatPump = 0x10,
+ kHeatingUsesFuel = 0x20,
+};
+
+// Bitmap for OccupancyBitmap
+enum class OccupancyBitmap : uint8_t
+{
+ kOccupied = 0x1,
+};
+
+// Bitmap for PresetTypeFeaturesBitmap
+enum class PresetTypeFeaturesBitmap : uint16_t
+{
+ kAutomatic = 0x1,
+ kSupportsNames = 0x2,
+};
+
+// Bitmap for ProgrammingOperationModeBitmap
+enum class ProgrammingOperationModeBitmap : uint8_t
+{
+ kScheduleActive = 0x1,
+ kAutoRecovery = 0x2,
+ kEconomy = 0x4,
+};
+
+// Bitmap for RelayStateBitmap
+enum class RelayStateBitmap : uint16_t
+{
+ kHeat = 0x1,
+ kCool = 0x2,
+ kFan = 0x4,
+ kHeatStage2 = 0x8,
+ kCoolStage2 = 0x10,
+ kFanStage2 = 0x20,
+ kFanStage3 = 0x40,
+};
+
+// Bitmap for RemoteSensingBitmap
+enum class RemoteSensingBitmap : uint8_t
+{
+ kLocalTemperature = 0x1,
+ kOutdoorTemperature = 0x2,
+ kOccupancy = 0x4,
+};
+
+// Bitmap for ScheduleDayOfWeekBitmap
+enum class ScheduleDayOfWeekBitmap : uint8_t
+{
+ kSunday = 0x1,
+ kMonday = 0x2,
+ kTuesday = 0x4,
+ kWednesday = 0x8,
+ kThursday = 0x10,
+ kFriday = 0x20,
+ kSaturday = 0x40,
+ kAway = 0x80,
+};
+
+// Bitmap for ScheduleModeBitmap
+enum class ScheduleModeBitmap : uint8_t
+{
+ kHeatSetpointPresent = 0x1,
+ kCoolSetpointPresent = 0x2,
+};
+
+// Bitmap for ScheduleTypeFeaturesBitmap
+enum class ScheduleTypeFeaturesBitmap : uint16_t
+{
+ kSupportsPresets = 0x1,
+ kSupportsSetpoints = 0x2,
+ kSupportsNames = 0x4,
+ kSupportsOff = 0x8,
+};
+} // namespace Thermostat
+
+namespace FanControl {
+
+// Enum for AirflowDirectionEnum
+enum class AirflowDirectionEnum : uint8_t
+{
+ kForward = 0x00,
+ kReverse = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for FanModeEnum
+enum class FanModeEnum : uint8_t
+{
+ kOff = 0x00,
+ kLow = 0x01,
+ kMedium = 0x02,
+ kHigh = 0x03,
+ kOn = 0x04,
+ kAuto = 0x05,
+ kSmart = 0x06,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 7,
+};
+
+// Enum for FanModeSequenceEnum
+enum class FanModeSequenceEnum : uint8_t
+{
+ kOffLowMedHigh = 0x00,
+ kOffLowHigh = 0x01,
+ kOffLowMedHighAuto = 0x02,
+ kOffLowHighAuto = 0x03,
+ kOffHighAuto = 0x04,
+ kOffHigh = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Enum for StepDirectionEnum
+enum class StepDirectionEnum : uint8_t
+{
+ kIncrease = 0x00,
+ kDecrease = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kMultiSpeed = 0x1,
+ kAuto = 0x2,
+ kRocking = 0x4,
+ kWind = 0x8,
+ kStep = 0x10,
+ kAirflowDirection = 0x20,
+};
+
+// Bitmap for RockBitmap
+enum class RockBitmap : uint8_t
+{
+ kRockLeftRight = 0x1,
+ kRockUpDown = 0x2,
+ kRockRound = 0x4,
+};
+
+// Bitmap for WindBitmap
+enum class WindBitmap : uint8_t
+{
+ kSleepWind = 0x1,
+ kNaturalWind = 0x2,
+};
+} // namespace FanControl
+
+namespace ThermostatUserInterfaceConfiguration {
+
+// Enum for KeypadLockoutEnum
+enum class KeypadLockoutEnum : uint8_t
+{
+ kNoLockout = 0x00,
+ kLockout1 = 0x01,
+ kLockout2 = 0x02,
+ kLockout3 = 0x03,
+ kLockout4 = 0x04,
+ kLockout5 = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Enum for ScheduleProgrammingVisibilityEnum
+enum class ScheduleProgrammingVisibilityEnum : uint8_t
+{
+ kScheduleProgrammingPermitted = 0x00,
+ kScheduleProgrammingDenied = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for TemperatureDisplayModeEnum
+enum class TemperatureDisplayModeEnum : uint8_t
+{
+ kCelsius = 0x00,
+ kFahrenheit = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+} // namespace ThermostatUserInterfaceConfiguration
+
+namespace ColorControl {
+
+// Enum for ColorLoopActionEnum
+enum class ColorLoopActionEnum : uint8_t
+{
+ kDeactivate = 0x00,
+ kActivateFromColorLoopStartEnhancedHue = 0x01,
+ kActivateFromEnhancedCurrentHue = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for ColorLoopDirectionEnum
+enum class ColorLoopDirectionEnum : uint8_t
+{
+ kDecrement = 0x00,
+ kIncrement = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ColorModeEnum
+enum class ColorModeEnum : uint8_t
+{
+ kCurrentHueAndCurrentSaturation = 0x00,
+ kCurrentXAndCurrentY = 0x01,
+ kColorTemperatureMireds = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for DirectionEnum
+enum class DirectionEnum : uint8_t
+{
+ kShortest = 0x00,
+ kLongest = 0x01,
+ kUp = 0x02,
+ kDown = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for DriftCompensationEnum
+enum class DriftCompensationEnum : uint8_t
+{
+ kNone = 0x00,
+ kOtherOrUnknown = 0x01,
+ kTemperatureMonitoring = 0x02,
+ kOpticalLuminanceMonitoringAndFeedback = 0x03,
+ kOpticalColorMonitoringAndFeedback = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Enum for EnhancedColorModeEnum
+enum class EnhancedColorModeEnum : uint8_t
+{
+ kCurrentHueAndCurrentSaturation = 0x00,
+ kCurrentXAndCurrentY = 0x01,
+ kColorTemperatureMireds = 0x02,
+ kEnhancedCurrentHueAndCurrentSaturation = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for MoveModeEnum
+enum class MoveModeEnum : uint8_t
+{
+ kStop = 0x00,
+ kUp = 0x01,
+ kDown = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for StepModeEnum
+enum class StepModeEnum : uint8_t
+{
+ kUp = 0x01,
+ kDown = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Bitmap for ColorCapabilitiesBitmap
+enum class ColorCapabilitiesBitmap : uint16_t
+{
+ kHueSaturation = 0x1,
+ kEnhancedHue = 0x2,
+ kColorLoop = 0x4,
+ kXy = 0x8,
+ kColorTemperature = 0x10,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kHueAndSaturation = 0x1,
+ kEnhancedHue = 0x2,
+ kColorLoop = 0x4,
+ kXy = 0x8,
+ kColorTemperature = 0x10,
+};
+
+// Bitmap for OptionsBitmap
+enum class OptionsBitmap : uint8_t
+{
+ kExecuteIfOff = 0x1,
+};
+
+// Bitmap for UpdateFlagsBitmap
+enum class UpdateFlagsBitmap : uint8_t
+{
+ kUpdateAction = 0x1,
+ kUpdateDirection = 0x2,
+ kUpdateTime = 0x4,
+ kUpdateStartHue = 0x8,
+};
+} // namespace ColorControl
+
+namespace BallastConfiguration {
+
+// Bitmap for BallastStatusBitmap
+enum class BallastStatusBitmap : uint8_t
+{
+ kBallastNonOperational = 0x1,
+ kLampFailure = 0x2,
+};
+
+// Bitmap for LampAlarmModeBitmap
+enum class LampAlarmModeBitmap : uint8_t
+{
+ kLampBurnHours = 0x1,
+};
+} // namespace BallastConfiguration
+
+namespace IlluminanceMeasurement {
+
+// Enum for LightSensorTypeEnum
+enum class LightSensorTypeEnum : uint8_t
+{
+ kPhotodiode = 0x00,
+ kCmos = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+} // namespace IlluminanceMeasurement
+
+namespace TemperatureMeasurement {} // namespace TemperatureMeasurement
+
+namespace PressureMeasurement {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kExtended = 0x1,
+};
+} // namespace PressureMeasurement
+
+namespace FlowMeasurement {} // namespace FlowMeasurement
+
+namespace RelativeHumidityMeasurement {} // namespace RelativeHumidityMeasurement
+
+namespace OccupancySensing {
+
+// Enum for OccupancySensorTypeEnum
+enum class OccupancySensorTypeEnum : uint8_t
+{
+ kPir = 0x00,
+ kUltrasonic = 0x01,
+ kPIRAndUltrasonic = 0x02,
+ kPhysicalContact = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kOther = 0x1,
+ kPassiveInfrared = 0x2,
+ kUltrasonic = 0x4,
+ kPhysicalContact = 0x8,
+ kActiveInfrared = 0x10,
+ kRadar = 0x20,
+ kRFSensing = 0x40,
+ kVision = 0x80,
+};
+
+// Bitmap for OccupancyBitmap
+enum class OccupancyBitmap : uint8_t
+{
+ kOccupied = 0x1,
+};
+
+// Bitmap for OccupancySensorTypeBitmap
+enum class OccupancySensorTypeBitmap : uint8_t
+{
+ kPir = 0x1,
+ kUltrasonic = 0x2,
+ kPhysicalContact = 0x4,
+};
+} // namespace OccupancySensing
+
+namespace CarbonMonoxideConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace CarbonMonoxideConcentrationMeasurement
+
+namespace CarbonDioxideConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace CarbonDioxideConcentrationMeasurement
+
+namespace NitrogenDioxideConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace NitrogenDioxideConcentrationMeasurement
+
+namespace OzoneConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace OzoneConcentrationMeasurement
+
+namespace Pm25ConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace Pm25ConcentrationMeasurement
+
+namespace FormaldehydeConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace FormaldehydeConcentrationMeasurement
+
+namespace Pm1ConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace Pm1ConcentrationMeasurement
+
+namespace Pm10ConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace Pm10ConcentrationMeasurement
+
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+
+namespace RadonConcentrationMeasurement {
+
+using LevelValueEnum = Clusters::detail::LevelValueEnum;
+
+using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;
+
+using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNumericMeasurement = 0x1,
+ kLevelIndication = 0x2,
+ kMediumLevel = 0x4,
+ kCriticalLevel = 0x8,
+ kPeakMeasurement = 0x10,
+ kAverageMeasurement = 0x20,
+};
+} // namespace RadonConcentrationMeasurement
+
+namespace WiFiNetworkManagement {} // namespace WiFiNetworkManagement
+
+namespace ThreadBorderRouterManagement {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kPANChange = 0x1,
+};
+} // namespace ThreadBorderRouterManagement
+
+namespace ThreadNetworkDirectory {} // namespace ThreadNetworkDirectory
+
+namespace WakeOnLan {} // namespace WakeOnLan
+
+namespace Channel {
+
+// Enum for ChannelTypeEnum
+enum class ChannelTypeEnum : uint8_t
+{
+ kSatellite = 0x00,
+ kCable = 0x01,
+ kTerrestrial = 0x02,
+ kOtt = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for LineupInfoTypeEnum
+enum class LineupInfoTypeEnum : uint8_t
+{
+ kMso = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kMultipleMatches = 0x01,
+ kNoMatches = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kChannelList = 0x1,
+ kLineupInfo = 0x2,
+ kElectronicGuide = 0x4,
+ kRecordProgram = 0x8,
+};
+
+// Bitmap for RecordingFlagBitmap
+enum class RecordingFlagBitmap : uint32_t
+{
+ kScheduled = 0x1,
+ kRecordSeries = 0x2,
+ kRecorded = 0x4,
+};
+} // namespace Channel
+
+namespace TargetNavigator {
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kTargetNotFound = 0x01,
+ kNotAllowed = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+} // namespace TargetNavigator
+
+namespace MediaPlayback {
+
+// Enum for CharacteristicEnum
+enum class CharacteristicEnum : uint8_t
+{
+ kForcedSubtitles = 0x00,
+ kDescribesVideo = 0x01,
+ kEasyToRead = 0x02,
+ kFrameBased = 0x03,
+ kMainProgram = 0x04,
+ kOriginalContent = 0x05,
+ kVoiceOverTranslation = 0x06,
+ kCaption = 0x07,
+ kSubtitle = 0x08,
+ kAlternate = 0x09,
+ kSupplementary = 0x0A,
+ kCommentary = 0x0B,
+ kDubbedTranslation = 0x0C,
+ kDescription = 0x0D,
+ kMetadata = 0x0E,
+ kEnhancedAudioIntelligibility = 0x0F,
+ kEmergency = 0x10,
+ kKaraoke = 0x11,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 18,
+};
+
+// Enum for PlaybackStateEnum
+enum class PlaybackStateEnum : uint8_t
+{
+ kPlaying = 0x00,
+ kPaused = 0x01,
+ kNotPlaying = 0x02,
+ kBuffering = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kInvalidStateForCommand = 0x01,
+ kNotAllowed = 0x02,
+ kNotActive = 0x03,
+ kSpeedOutOfRange = 0x04,
+ kSeekOutOfRange = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kAdvancedSeek = 0x1,
+ kVariableSpeed = 0x2,
+ kTextTracks = 0x4,
+ kAudioTracks = 0x8,
+ kAudioAdvance = 0x10,
+};
+} // namespace MediaPlayback
+
+namespace MediaInput {
+
+// Enum for InputTypeEnum
+enum class InputTypeEnum : uint8_t
+{
+ kInternal = 0x00,
+ kAux = 0x01,
+ kCoax = 0x02,
+ kComposite = 0x03,
+ kHdmi = 0x04,
+ kInput = 0x05,
+ kLine = 0x06,
+ kOptical = 0x07,
+ kVideo = 0x08,
+ kScart = 0x09,
+ kUsb = 0x0A,
+ kOther = 0x0B,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 12,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNameUpdates = 0x1,
+};
+} // namespace MediaInput
+
+namespace LowPower {} // namespace LowPower
+
+namespace KeypadInput {
+
+// Enum for CECKeyCodeEnum
+enum class CECKeyCodeEnum : uint8_t
+{
+ kSelect = 0x00,
+ kUp = 0x01,
+ kDown = 0x02,
+ kLeft = 0x03,
+ kRight = 0x04,
+ kRightUp = 0x05,
+ kRightDown = 0x06,
+ kLeftUp = 0x07,
+ kLeftDown = 0x08,
+ kRootMenu = 0x09,
+ kSetupMenu = 0x0A,
+ kContentsMenu = 0x0B,
+ kFavoriteMenu = 0x0C,
+ kExit = 0x0D,
+ kMediaTopMenu = 0x10,
+ kMediaContextSensitiveMenu = 0x11,
+ kNumberEntryMode = 0x1D,
+ kNumber11 = 0x1E,
+ kNumber12 = 0x1F,
+ kNumber0OrNumber10 = 0x20,
+ kNumbers1 = 0x21,
+ kNumbers2 = 0x22,
+ kNumbers3 = 0x23,
+ kNumbers4 = 0x24,
+ kNumbers5 = 0x25,
+ kNumbers6 = 0x26,
+ kNumbers7 = 0x27,
+ kNumbers8 = 0x28,
+ kNumbers9 = 0x29,
+ kDot = 0x2A,
+ kEnter = 0x2B,
+ kClear = 0x2C,
+ kNextFavorite = 0x2F,
+ kChannelUp = 0x30,
+ kChannelDown = 0x31,
+ kPreviousChannel = 0x32,
+ kSoundSelect = 0x33,
+ kInputSelect = 0x34,
+ kDisplayInformation = 0x35,
+ kHelp = 0x36,
+ kPageUp = 0x37,
+ kPageDown = 0x38,
+ kPower = 0x40,
+ kVolumeUp = 0x41,
+ kVolumeDown = 0x42,
+ kMute = 0x43,
+ kPlay = 0x44,
+ kStop = 0x45,
+ kPause = 0x46,
+ kRecord = 0x47,
+ kRewind = 0x48,
+ kFastForward = 0x49,
+ kEject = 0x4A,
+ kForward = 0x4B,
+ kBackward = 0x4C,
+ kStopRecord = 0x4D,
+ kPauseRecord = 0x4E,
+ kReserved = 0x4F,
+ kAngle = 0x50,
+ kSubPicture = 0x51,
+ kVideoOnDemand = 0x52,
+ kElectronicProgramGuide = 0x53,
+ kTimerProgramming = 0x54,
+ kInitialConfiguration = 0x55,
+ kSelectBroadcastType = 0x56,
+ kSelectSoundPresentation = 0x57,
+ kPlayFunction = 0x60,
+ kPausePlayFunction = 0x61,
+ kRecordFunction = 0x62,
+ kPauseRecordFunction = 0x63,
+ kStopFunction = 0x64,
+ kMuteFunction = 0x65,
+ kRestoreVolumeFunction = 0x66,
+ kTuneFunction = 0x67,
+ kSelectMediaFunction = 0x68,
+ kSelectAvInputFunction = 0x69,
+ kSelectAudioInputFunction = 0x6A,
+ kPowerToggleFunction = 0x6B,
+ kPowerOffFunction = 0x6C,
+ kPowerOnFunction = 0x6D,
+ kF1Blue = 0x71,
+ kF2Red = 0x72,
+ kF3Green = 0x73,
+ kF4Yellow = 0x74,
+ kF5 = 0x75,
+ kData = 0x76,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 14,
+};
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kUnsupportedKey = 0x01,
+ kInvalidKeyInCurrentState = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNavigationKeyCodes = 0x1,
+ kLocationKeys = 0x2,
+ kNumberKeys = 0x4,
+};
+} // namespace KeypadInput
+
+namespace ContentLauncher {
+
+// Enum for CharacteristicEnum
+enum class CharacteristicEnum : uint8_t
+{
+ kForcedSubtitles = 0x00,
+ kDescribesVideo = 0x01,
+ kEasyToRead = 0x02,
+ kFrameBased = 0x03,
+ kMainProgram = 0x04,
+ kOriginalContent = 0x05,
+ kVoiceOverTranslation = 0x06,
+ kCaption = 0x07,
+ kSubtitle = 0x08,
+ kAlternate = 0x09,
+ kSupplementary = 0x0A,
+ kCommentary = 0x0B,
+ kDubbedTranslation = 0x0C,
+ kDescription = 0x0D,
+ kMetadata = 0x0E,
+ kEnhancedAudioIntelligibility = 0x0F,
+ kEmergency = 0x10,
+ kKaraoke = 0x11,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 18,
+};
+
+// Enum for MetricTypeEnum
+enum class MetricTypeEnum : uint8_t
+{
+ kPixels = 0x00,
+ kPercentage = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ParameterEnum
+enum class ParameterEnum : uint8_t
+{
+ kActor = 0x00,
+ kChannel = 0x01,
+ kCharacter = 0x02,
+ kDirector = 0x03,
+ kEvent = 0x04,
+ kFranchise = 0x05,
+ kGenre = 0x06,
+ kLeague = 0x07,
+ kPopularity = 0x08,
+ kProvider = 0x09,
+ kSport = 0x0A,
+ kSportsTeam = 0x0B,
+ kType = 0x0C,
+ kVideo = 0x0D,
+ kSeason = 0x0E,
+ kEpisode = 0x0F,
+ kAny = 0x10,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 17,
+};
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kURLNotAvailable = 0x01,
+ kAuthFailed = 0x02,
+ kTextTrackNotAvailable = 0x03,
+ kAudioTrackNotAvailable = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kContentSearch = 0x1,
+ kURLPlayback = 0x2,
+ kAdvancedSeek = 0x4,
+ kTextTracks = 0x8,
+ kAudioTracks = 0x10,
+};
+
+// Bitmap for SupportedProtocolsBitmap
+enum class SupportedProtocolsBitmap : uint32_t
+{
+ kDash = 0x1,
+ kHls = 0x2,
+};
+} // namespace ContentLauncher
+
+namespace AudioOutput {
+
+// Enum for OutputTypeEnum
+enum class OutputTypeEnum : uint8_t
+{
+ kHdmi = 0x00,
+ kBt = 0x01,
+ kOptical = 0x02,
+ kHeadphone = 0x03,
+ kInternal = 0x04,
+ kOther = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kNameUpdates = 0x1,
+};
+} // namespace AudioOutput
+
+namespace ApplicationLauncher {
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kAppNotAvailable = 0x01,
+ kSystemBusy = 0x02,
+ kPendingUserApproval = 0x03,
+ kDownloading = 0x04,
+ kInstalling = 0x05,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 6,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kApplicationPlatform = 0x1,
+};
+} // namespace ApplicationLauncher
+
+namespace ApplicationBasic {
+
+// Enum for ApplicationStatusEnum
+enum class ApplicationStatusEnum : uint8_t
+{
+ kStopped = 0x00,
+ kActiveVisibleFocus = 0x01,
+ kActiveHidden = 0x02,
+ kActiveVisibleNotFocus = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+} // namespace ApplicationBasic
+
+namespace AccountLogin {} // namespace AccountLogin
+
+namespace ContentControl {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kScreenTime = 0x1,
+ kPINManagement = 0x2,
+ kBlockUnrated = 0x4,
+ kOnDemandContentRating = 0x8,
+ kScheduledContentRating = 0x10,
+};
+} // namespace ContentControl
+
+namespace ContentAppObserver {
+
+// Enum for StatusEnum
+enum class StatusEnum : uint8_t
+{
+ kSuccess = 0x00,
+ kUnexpectedData = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+} // namespace ContentAppObserver
+
+namespace ZoneManagement {
+
+// Enum for StatusCodeEnum
+enum class StatusCodeEnum : uint8_t
+{
+ kZoneNotFound = 0x02,
+ kZoneInUse = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 0,
+};
+
+// Enum for ZoneEventStoppedReasonEnum
+enum class ZoneEventStoppedReasonEnum : uint8_t
+{
+ kActionStopped = 0x00,
+ kTimeout = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ZoneEventTriggeredReasonEnum
+enum class ZoneEventTriggeredReasonEnum : uint8_t
+{
+ kMotion = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Enum for ZoneSourceEnum
+enum class ZoneSourceEnum : uint8_t
+{
+ kMfg = 0x00,
+ kUser = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ZoneTypeEnum
+enum class ZoneTypeEnum : uint8_t
+{
+ kTwoDCARTZone = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+// Enum for ZoneUseEnum
+enum class ZoneUseEnum : uint8_t
+{
+ kMotion = 0x00,
+ kPrivacy = 0x01,
+ kFocus = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kTwoDimensionalCartesianZone = 0x1,
+ kPerZoneSensitivity = 0x2,
+};
+} // namespace ZoneManagement
+
+namespace CameraAvStreamManagement {
+
+// Enum for AudioCodecEnum
+enum class AudioCodecEnum : uint8_t
+{
+ kOpus = 0x00,
+ kAacLc = 0x01,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 2,
+};
+
+// Enum for ImageCodecEnum
+enum class ImageCodecEnum : uint8_t
+{
+ kJpeg = 0x00,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 1,
+};
+
+using StreamUsageEnum = Clusters::detail::StreamUsageEnum;
+
+// Enum for TriStateAutoEnum
+enum class TriStateAutoEnum : uint8_t
+{
+ kOff = 0x00,
+ kOn = 0x01,
+ kAuto = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for TwoWayTalkSupportTypeEnum
+enum class TwoWayTalkSupportTypeEnum : uint8_t
+{
+ kNotSupported = 0x00,
+ kHalfDuplex = 0x01,
+ kFullDuplex = 0x02,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 3,
+};
+
+// Enum for VideoCodecEnum
+enum class VideoCodecEnum : uint8_t
+{
+ kH264 = 0x00,
+ kHevc = 0x01,
+ kVvc = 0x02,
+ kAv1 = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kAudio = 0x1,
+ kVideo = 0x2,
+ kSnapshot = 0x4,
+ kPrivacy = 0x8,
+ kSpeaker = 0x10,
+ kImageControl = 0x20,
+ kWatermark = 0x40,
+ kOnScreenDisplay = 0x80,
+ kLocalStorage = 0x100,
+};
+} // namespace CameraAvStreamManagement
+
+namespace CameraAvSettingsUserLevelManagement {
+
+// Bitmap for Feature
+enum class Feature : uint32_t
+{
+ kDigitalPTZ = 0x1,
+ kMechanicalPan = 0x2,
+ kMechanicalTilt = 0x4,
+ kMechanicalZoom = 0x8,
+ kMechanicalPresets = 0x10,
+};
+} // namespace CameraAvSettingsUserLevelManagement
+
+namespace WebRTCTransportProvider {
+
+using StreamUsageEnum = Clusters::detail::StreamUsageEnum;
+
+using WebRTCEndReasonEnum = Clusters::detail::WebRTCEndReasonEnum;
+
+using WebRTCMetadataOptions = Clusters::detail::WebRTCMetadataOptions;
+} // namespace WebRTCTransportProvider
+
+namespace WebRTCTransportRequestor {
+
+using StreamUsageEnum = Clusters::detail::StreamUsageEnum;
+
+using WebRTCEndReasonEnum = Clusters::detail::WebRTCEndReasonEnum;
+
+using WebRTCMetadataOptions = Clusters::detail::WebRTCMetadataOptions;
+} // namespace WebRTCTransportRequestor
+
+namespace Chime {} // namespace Chime
+
+namespace EcosystemInformation {} // namespace EcosystemInformation
+
+namespace CommissionerControl {
+
+// Bitmap for SupportedDeviceCategoryBitmap
+enum class SupportedDeviceCategoryBitmap : uint32_t
+{
+ kFabricSynchronization = 0x1,
+};
+} // namespace CommissionerControl
+
+namespace UnitTesting {
+
+// Enum for SimpleEnum
+enum class SimpleEnum : uint8_t
+{
+ kUnspecified = 0x00,
+ kValueA = 0x01,
+ kValueB = 0x02,
+ kValueC = 0x03,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 4,
+};
+
+// Bitmap for Bitmap16MaskMap
+enum class Bitmap16MaskMap : uint16_t
+{
+ kMaskVal1 = 0x1,
+ kMaskVal2 = 0x2,
+ kMaskVal3 = 0x4,
+ kMaskVal4 = 0x4000,
+};
+
+// Bitmap for Bitmap32MaskMap
+enum class Bitmap32MaskMap : uint32_t
+{
+ kMaskVal1 = 0x1,
+ kMaskVal2 = 0x2,
+ kMaskVal3 = 0x4,
+ kMaskVal4 = 0x40000000,
+};
+
+// Bitmap for Bitmap64MaskMap
+enum class Bitmap64MaskMap : uint64_t
+{
+ kMaskVal1 = 0x1,
+ kMaskVal2 = 0x2,
+ kMaskVal3 = 0x4,
+ kMaskVal4 = 0x4000000000000000,
+};
+
+// Bitmap for Bitmap8MaskMap
+enum class Bitmap8MaskMap : uint8_t
+{
+ kMaskVal1 = 0x1,
+ kMaskVal2 = 0x2,
+ kMaskVal3 = 0x4,
+ kMaskVal4 = 0x40,
+};
+
+// Bitmap for SimpleBitmap
+enum class SimpleBitmap : uint8_t
+{
+ kValueA = 0x1,
+ kValueB = 0x2,
+ kValueC = 0x4,
+};
+} // namespace UnitTesting
+
+namespace FaultInjection {
+
+// Enum for FaultType
+enum class FaultType : uint8_t
+{
+ kUnspecified = 0x00,
+ kSystemFault = 0x01,
+ kInetFault = 0x02,
+ kChipFault = 0x03,
+ kCertFault = 0x04,
+ // All received enum values that are not listed above will be mapped
+ // to kUnknownEnumValue. This is a helper enum value that should only
+ // be used by code to process how it handles receiving and unknown
+ // enum value. This specific should never be transmitted.
+ kUnknownEnumValue = 5,
+};
+} // namespace FaultInjection
+
+namespace SampleManufacturerSpecific {} // namespace SampleManufacturerSpecific
+
+namespace SampleExternalManufacturerSpecific {} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
+
+// Included at the end, so all our definitions above are available.
+#include <app/common/CompatEnumNames.h>
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
new file mode 100644
index 00000000000000..1bccde328207c1
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
@@ -0,0 +1,35570 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/data-model/WrappedStructEncoder.h>
+
+#include <variant>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace detail {
+
+class StructDecodeIterator
+{
+public:
+ // may return a context tag, a CHIP_ERROR (end iteration)
+ using EntryElement = std::variant<uint8_t, CHIP_ERROR>;
+
+ StructDecodeIterator(TLV::TLVReader & reader) : mReader(reader) {}
+
+ // Iterate through structure elements. Returns one of:
+ // - uint8_t CONTEXT TAG (keep iterating)
+ // - CHIP_ERROR (including CHIP_NO_ERROR) which should be a final
+ // return value (stop iterating)
+ EntryElement Next()
+ {
+ if (!mEntered)
+ {
+ VerifyOrReturnError(TLV::kTLVType_Structure == mReader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+ ReturnErrorOnFailure(mReader.EnterContainer(mOuter));
+ mEntered = true;
+ }
+
+ while (true)
+ {
+ CHIP_ERROR err = mReader.Next();
+ if (err != CHIP_NO_ERROR)
+ {
+ VerifyOrReturnError(err == CHIP_ERROR_END_OF_TLV, err);
+ break;
+ }
+
+ const TLV::Tag tag = mReader.GetTag();
+ if (!TLV::IsContextTag(tag))
+ {
+ continue;
+ }
+
+ // we know context tags are 8-bit
+ return static_cast<uint8_t>(TLV::TagNumFromTag(tag));
+ }
+
+ return mReader.ExitContainer(mOuter);
+ }
+
+private:
+ bool mEntered = false;
+ TLV::TLVType mOuter;
+ TLV::TLVReader & mReader;
+};
+
+// Structs shared across multiple clusters.
+namespace Structs {
+
+namespace ModeTagStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMfgCode), mfgCode);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMfgCode))
+ {
+ err = DataModel::Decode(reader, mfgCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ModeTagStruct
+
+namespace ModeOptionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ encoder.Encode(to_underlying(Fields::kMode), mode);
+ encoder.Encode(to_underlying(Fields::kModeTags), modeTags);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else if (__context_tag == to_underlying(Fields::kMode))
+ {
+ err = DataModel::Decode(reader, mode);
+ }
+ else if (__context_tag == to_underlying(Fields::kModeTags))
+ {
+ err = DataModel::Decode(reader, modeTags);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ModeOptionStruct
+
+namespace MeasurementAccuracyRangeStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRangeMin), rangeMin);
+ encoder.Encode(to_underlying(Fields::kRangeMax), rangeMax);
+ encoder.Encode(to_underlying(Fields::kPercentMax), percentMax);
+ encoder.Encode(to_underlying(Fields::kPercentMin), percentMin);
+ encoder.Encode(to_underlying(Fields::kPercentTypical), percentTypical);
+ encoder.Encode(to_underlying(Fields::kFixedMax), fixedMax);
+ encoder.Encode(to_underlying(Fields::kFixedMin), fixedMin);
+ encoder.Encode(to_underlying(Fields::kFixedTypical), fixedTypical);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRangeMin))
+ {
+ err = DataModel::Decode(reader, rangeMin);
+ }
+ else if (__context_tag == to_underlying(Fields::kRangeMax))
+ {
+ err = DataModel::Decode(reader, rangeMax);
+ }
+ else if (__context_tag == to_underlying(Fields::kPercentMax))
+ {
+ err = DataModel::Decode(reader, percentMax);
+ }
+ else if (__context_tag == to_underlying(Fields::kPercentMin))
+ {
+ err = DataModel::Decode(reader, percentMin);
+ }
+ else if (__context_tag == to_underlying(Fields::kPercentTypical))
+ {
+ err = DataModel::Decode(reader, percentTypical);
+ }
+ else if (__context_tag == to_underlying(Fields::kFixedMax))
+ {
+ err = DataModel::Decode(reader, fixedMax);
+ }
+ else if (__context_tag == to_underlying(Fields::kFixedMin))
+ {
+ err = DataModel::Decode(reader, fixedMin);
+ }
+ else if (__context_tag == to_underlying(Fields::kFixedTypical))
+ {
+ err = DataModel::Decode(reader, fixedTypical);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MeasurementAccuracyRangeStruct
+
+namespace MeasurementAccuracyStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMeasurementType), measurementType);
+ encoder.Encode(to_underlying(Fields::kMeasured), measured);
+ encoder.Encode(to_underlying(Fields::kMinMeasuredValue), minMeasuredValue);
+ encoder.Encode(to_underlying(Fields::kMaxMeasuredValue), maxMeasuredValue);
+ encoder.Encode(to_underlying(Fields::kAccuracyRanges), accuracyRanges);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMeasurementType))
+ {
+ err = DataModel::Decode(reader, measurementType);
+ }
+ else if (__context_tag == to_underlying(Fields::kMeasured))
+ {
+ err = DataModel::Decode(reader, measured);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinMeasuredValue))
+ {
+ err = DataModel::Decode(reader, minMeasuredValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxMeasuredValue))
+ {
+ err = DataModel::Decode(reader, maxMeasuredValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kAccuracyRanges))
+ {
+ err = DataModel::Decode(reader, accuracyRanges);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MeasurementAccuracyStruct
+
+namespace DeviceTypeStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDeviceType), deviceType);
+ encoder.Encode(to_underlying(Fields::kRevision), revision);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDeviceType))
+ {
+ err = DataModel::Decode(reader, deviceType);
+ }
+ else if (__context_tag == to_underlying(Fields::kRevision))
+ {
+ err = DataModel::Decode(reader, revision);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace DeviceTypeStruct
+
+namespace ApplicationStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCatalogVendorID), catalogVendorID);
+ encoder.Encode(to_underlying(Fields::kApplicationID), applicationID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCatalogVendorID))
+ {
+ err = DataModel::Decode(reader, catalogVendorID);
+ }
+ else if (__context_tag == to_underlying(Fields::kApplicationID))
+ {
+ err = DataModel::Decode(reader, applicationID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ApplicationStruct
+
+namespace ErrorStateStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kErrorStateID), errorStateID);
+ encoder.Encode(to_underlying(Fields::kErrorStateLabel), errorStateLabel);
+ encoder.Encode(to_underlying(Fields::kErrorStateDetails), errorStateDetails);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorStateID))
+ {
+ err = DataModel::Decode(reader, errorStateID);
+ }
+ else if (__context_tag == to_underlying(Fields::kErrorStateLabel))
+ {
+ err = DataModel::Decode(reader, errorStateLabel);
+ }
+ else if (__context_tag == to_underlying(Fields::kErrorStateDetails))
+ {
+ err = DataModel::Decode(reader, errorStateDetails);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ErrorStateStruct
+
+namespace ICEServerStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUrls), urls);
+ encoder.Encode(to_underlying(Fields::kUsername), username);
+ encoder.Encode(to_underlying(Fields::kCredential), credential);
+ encoder.Encode(to_underlying(Fields::kCaid), caid);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUrls))
+ {
+ err = DataModel::Decode(reader, urls);
+ }
+ else if (__context_tag == to_underlying(Fields::kUsername))
+ {
+ err = DataModel::Decode(reader, username);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredential))
+ {
+ err = DataModel::Decode(reader, credential);
+ }
+ else if (__context_tag == to_underlying(Fields::kCaid))
+ {
+ err = DataModel::Decode(reader, caid);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ICEServerStruct
+
+namespace LabelStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LabelStruct
+
+namespace OperationalStateStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperationalStateID), operationalStateID);
+ encoder.Encode(to_underlying(Fields::kOperationalStateLabel), operationalStateLabel);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperationalStateID))
+ {
+ err = DataModel::Decode(reader, operationalStateID);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperationalStateLabel))
+ {
+ err = DataModel::Decode(reader, operationalStateLabel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace OperationalStateStruct
+
+namespace ViewportStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kX1), x1);
+ encoder.Encode(to_underlying(Fields::kY1), y1);
+ encoder.Encode(to_underlying(Fields::kX2), x2);
+ encoder.Encode(to_underlying(Fields::kY2), y2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kX1))
+ {
+ err = DataModel::Decode(reader, x1);
+ }
+ else if (__context_tag == to_underlying(Fields::kY1))
+ {
+ err = DataModel::Decode(reader, y1);
+ }
+ else if (__context_tag == to_underlying(Fields::kX2))
+ {
+ err = DataModel::Decode(reader, x2);
+ }
+ else if (__context_tag == to_underlying(Fields::kY2))
+ {
+ err = DataModel::Decode(reader, y2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ViewportStruct
+
+namespace WebRTCSessionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kId), id);
+ encoder.Encode(to_underlying(Fields::kPeerNodeID), peerNodeID);
+ encoder.Encode(to_underlying(Fields::kPeerFabricIndex), peerFabricIndex);
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ encoder.Encode(to_underlying(Fields::kMetadataOptions), metadataOptions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else if (__context_tag == to_underlying(Fields::kPeerNodeID))
+ {
+ err = DataModel::Decode(reader, peerNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kPeerFabricIndex))
+ {
+ err = DataModel::Decode(reader, peerFabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetadataOptions))
+ {
+ err = DataModel::Decode(reader, metadataOptions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace WebRTCSessionStruct
+} // namespace Structs
+} // namespace detail
+
+namespace Globals {
+// Global structs
+namespace Structs {
+
+namespace TestGlobalStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kMyBitmap), myBitmap);
+ encoder.Encode(to_underlying(Fields::kMyEnum), myEnum);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kMyBitmap))
+ {
+ err = DataModel::Decode(reader, myBitmap);
+ }
+ else if (__context_tag == to_underlying(Fields::kMyEnum))
+ {
+ err = DataModel::Decode(reader, myEnum);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TestGlobalStruct
+
+namespace LocationDescriptorStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLocationName), locationName);
+ encoder.Encode(to_underlying(Fields::kFloorNumber), floorNumber);
+ encoder.Encode(to_underlying(Fields::kAreaType), areaType);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLocationName))
+ {
+ err = DataModel::Decode(reader, locationName);
+ }
+ else if (__context_tag == to_underlying(Fields::kFloorNumber))
+ {
+ err = DataModel::Decode(reader, floorNumber);
+ }
+ else if (__context_tag == to_underlying(Fields::kAreaType))
+ {
+ err = DataModel::Decode(reader, areaType);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LocationDescriptorStruct
+
+namespace AtomicAttributeStatusStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAttributeID), attributeID);
+ encoder.Encode(to_underlying(Fields::kStatusCode), statusCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAttributeID))
+ {
+ err = DataModel::Decode(reader, attributeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusCode))
+ {
+ err = DataModel::Decode(reader, statusCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AtomicAttributeStatusStruct
+
+} // namespace Structs
+} // namespace Globals
+
+namespace Identify {
+
+namespace Commands {
+namespace Identify {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIdentifyTime), identifyTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIdentifyTime))
+ {
+ err = DataModel::Decode(reader, identifyTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Identify.
+namespace TriggerEffect {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEffectIdentifier), effectIdentifier);
+ encoder.Encode(to_underlying(Fields::kEffectVariant), effectVariant);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEffectIdentifier))
+ {
+ err = DataModel::Decode(reader, effectIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kEffectVariant))
+ {
+ err = DataModel::Decode(reader, effectVariant);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TriggerEffect.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::IdentifyTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, identifyTime);
+ case Attributes::IdentifyType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, identifyType);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Identify
+namespace Groups {
+
+namespace Commands {
+namespace AddGroup {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kGroupName), groupName);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupName))
+ {
+ err = DataModel::Decode(reader, groupName);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddGroup.
+namespace AddGroupResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddGroupResponse.
+namespace ViewGroup {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ViewGroup.
+namespace ViewGroupResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kGroupName), groupName);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupName))
+ {
+ err = DataModel::Decode(reader, groupName);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ViewGroupResponse.
+namespace GetGroupMembership {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupList), groupList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupList))
+ {
+ err = DataModel::Decode(reader, groupList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetGroupMembership.
+namespace GetGroupMembershipResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCapacity), capacity);
+ encoder.Encode(to_underlying(Fields::kGroupList), groupList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCapacity))
+ {
+ err = DataModel::Decode(reader, capacity);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupList))
+ {
+ err = DataModel::Decode(reader, groupList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetGroupMembershipResponse.
+namespace RemoveGroup {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveGroup.
+namespace RemoveGroupResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveGroupResponse.
+namespace RemoveAllGroups {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace RemoveAllGroups.
+namespace AddGroupIfIdentifying {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kGroupName), groupName);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupName))
+ {
+ err = DataModel::Decode(reader, groupName);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddGroupIfIdentifying.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::NameSupport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nameSupport);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Groups
+namespace OnOff {
+
+namespace Commands {
+namespace Off {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Off.
+namespace On {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace On.
+namespace Toggle {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Toggle.
+namespace OffWithEffect {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEffectIdentifier), effectIdentifier);
+ encoder.Encode(to_underlying(Fields::kEffectVariant), effectVariant);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEffectIdentifier))
+ {
+ err = DataModel::Decode(reader, effectIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kEffectVariant))
+ {
+ err = DataModel::Decode(reader, effectVariant);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OffWithEffect.
+namespace OnWithRecallGlobalScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace OnWithRecallGlobalScene.
+namespace OnWithTimedOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOnOffControl), onOffControl);
+ encoder.Encode(to_underlying(Fields::kOnTime), onTime);
+ encoder.Encode(to_underlying(Fields::kOffWaitTime), offWaitTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOnOffControl))
+ {
+ err = DataModel::Decode(reader, onOffControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kOnTime))
+ {
+ err = DataModel::Decode(reader, onTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOffWaitTime))
+ {
+ err = DataModel::Decode(reader, offWaitTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OnWithTimedOff.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::OnOff::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onOff);
+ case Attributes::GlobalSceneControl::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, globalSceneControl);
+ case Attributes::OnTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onTime);
+ case Attributes::OffWaitTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, offWaitTime);
+ case Attributes::StartUpOnOff::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpOnOff);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace OnOff
+namespace LevelControl {
+
+namespace Commands {
+namespace MoveToLevel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLevel), level);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLevel))
+ {
+ err = DataModel::Decode(reader, level);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToLevel.
+namespace Move {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
+ encoder.Encode(to_underlying(Fields::kRate), rate);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMoveMode))
+ {
+ err = DataModel::Decode(reader, moveMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kRate))
+ {
+ err = DataModel::Decode(reader, rate);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Move.
+namespace Step {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
+ encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepMode))
+ {
+ err = DataModel::Decode(reader, stepMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepSize))
+ {
+ err = DataModel::Decode(reader, stepSize);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Step.
+namespace Stop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Stop.
+namespace MoveToLevelWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLevel), level);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLevel))
+ {
+ err = DataModel::Decode(reader, level);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToLevelWithOnOff.
+namespace MoveWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
+ encoder.Encode(to_underlying(Fields::kRate), rate);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMoveMode))
+ {
+ err = DataModel::Decode(reader, moveMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kRate))
+ {
+ err = DataModel::Decode(reader, rate);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveWithOnOff.
+namespace StepWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
+ encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepMode))
+ {
+ err = DataModel::Decode(reader, stepMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepSize))
+ {
+ err = DataModel::Decode(reader, stepSize);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StepWithOnOff.
+namespace StopWithOnOff {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StopWithOnOff.
+namespace MoveToClosestFrequency {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kFrequency), frequency);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFrequency))
+ {
+ err = DataModel::Decode(reader, frequency);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToClosestFrequency.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CurrentLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentLevel);
+ case Attributes::RemainingTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, remainingTime);
+ case Attributes::MinLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minLevel);
+ case Attributes::MaxLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxLevel);
+ case Attributes::CurrentFrequency::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentFrequency);
+ case Attributes::MinFrequency::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minFrequency);
+ case Attributes::MaxFrequency::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxFrequency);
+ case Attributes::Options::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, options);
+ case Attributes::OnOffTransitionTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onOffTransitionTime);
+ case Attributes::OnLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onLevel);
+ case Attributes::OnTransitionTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onTransitionTime);
+ case Attributes::OffTransitionTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, offTransitionTime);
+ case Attributes::DefaultMoveRate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultMoveRate);
+ case Attributes::StartUpCurrentLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpCurrentLevel);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace LevelControl
+namespace PulseWidthModulation {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace PulseWidthModulation
+namespace Descriptor {
+namespace Structs {
+
+namespace SemanticTagStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMfgCode), mfgCode);
+ encoder.Encode(to_underlying(Fields::kNamespaceID), namespaceID);
+ encoder.Encode(to_underlying(Fields::kTag), tag);
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMfgCode))
+ {
+ err = DataModel::Decode(reader, mfgCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kNamespaceID))
+ {
+ err = DataModel::Decode(reader, namespaceID);
+ }
+ else if (__context_tag == to_underlying(Fields::kTag))
+ {
+ err = DataModel::Decode(reader, tag);
+ }
+ else if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SemanticTagStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::DeviceTypeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, deviceTypeList);
+ case Attributes::ServerList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, serverList);
+ case Attributes::ClientList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clientList);
+ case Attributes::PartsList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, partsList);
+ case Attributes::TagList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tagList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Descriptor
+namespace Binding {
+namespace Structs {
+
+namespace TargetStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ encoder.Encode(to_underlying(Fields::kNode), node);
+ encoder.Encode(to_underlying(Fields::kGroup), group);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ encoder.Encode(to_underlying(Fields::kCluster), cluster);
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNode))
+ {
+ err = DataModel::Decode(reader, node);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroup))
+ {
+ err = DataModel::Decode(reader, group);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kCluster))
+ {
+ err = DataModel::Decode(reader, cluster);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TargetStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Binding::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, binding);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Binding
+namespace AccessControl {
+namespace Structs {
+
+namespace AccessRestrictionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kType), type);
+ encoder.Encode(to_underlying(Fields::kId), id);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AccessRestrictionStruct
+
+namespace CommissioningAccessRestrictionEntryStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ encoder.Encode(to_underlying(Fields::kCluster), cluster);
+ encoder.Encode(to_underlying(Fields::kRestrictions), restrictions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kCluster))
+ {
+ err = DataModel::Decode(reader, cluster);
+ }
+ else if (__context_tag == to_underlying(Fields::kRestrictions))
+ {
+ err = DataModel::Decode(reader, restrictions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace CommissioningAccessRestrictionEntryStruct
+
+namespace AccessRestrictionEntryStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kCluster), cluster);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kRestrictions), restrictions);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kCluster))
+ {
+ err = DataModel::Decode(reader, cluster);
+ }
+ else if (__context_tag == to_underlying(Fields::kRestrictions))
+ {
+ err = DataModel::Decode(reader, restrictions);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AccessRestrictionEntryStruct
+
+namespace AccessControlTargetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCluster), cluster);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ encoder.Encode(to_underlying(Fields::kDeviceType), deviceType);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCluster))
+ {
+ err = DataModel::Decode(reader, cluster);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeviceType))
+ {
+ err = DataModel::Decode(reader, deviceType);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AccessControlTargetStruct
+
+namespace AccessControlEntryStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kPrivilege), privilege);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kAuthMode), authMode);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kSubjects), subjects);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kTargets), targets);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPrivilege))
+ {
+ err = DataModel::Decode(reader, privilege);
+ }
+ else if (__context_tag == to_underlying(Fields::kAuthMode))
+ {
+ err = DataModel::Decode(reader, authMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kSubjects))
+ {
+ err = DataModel::Decode(reader, subjects);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargets))
+ {
+ err = DataModel::Decode(reader, targets);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AccessControlEntryStruct
+
+namespace AccessControlExtensionStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kData), data);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AccessControlExtensionStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ReviewFabricRestrictions {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArl), arl);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArl))
+ {
+ err = DataModel::Decode(reader, arl);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReviewFabricRestrictions.
+namespace ReviewFabricRestrictionsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kToken), token);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kToken))
+ {
+ err = DataModel::Decode(reader, token);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReviewFabricRestrictionsResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Acl::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acl);
+ case Attributes::Extension::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, extension);
+ case Attributes::SubjectsPerAccessControlEntry::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, subjectsPerAccessControlEntry);
+ case Attributes::TargetsPerAccessControlEntry::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, targetsPerAccessControlEntry);
+ case Attributes::AccessControlEntriesPerFabric::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, accessControlEntriesPerFabric);
+ case Attributes::CommissioningARL::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, commissioningARL);
+ case Attributes::Arl::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, arl);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace AccessControlEntryChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminNodeID), adminNodeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminPasscodeID), adminPasscodeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kChangeType), changeType));
+ ReturnErrorOnFailure(DataModel::EncodeForRead(aWriter, TLV::ContextTag(Fields::kLatestValue), GetFabricIndex(), latestValue));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAdminNodeID))
+ {
+ err = DataModel::Decode(reader, adminNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAdminPasscodeID))
+ {
+ err = DataModel::Decode(reader, adminPasscodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kChangeType))
+ {
+ err = DataModel::Decode(reader, changeType);
+ }
+ else if (__context_tag == to_underlying(Fields::kLatestValue))
+ {
+ err = DataModel::Decode(reader, latestValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AccessControlEntryChanged.
+namespace AccessControlExtensionChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminNodeID), adminNodeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminPasscodeID), adminPasscodeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kChangeType), changeType));
+ ReturnErrorOnFailure(DataModel::EncodeForRead(aWriter, TLV::ContextTag(Fields::kLatestValue), GetFabricIndex(), latestValue));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAdminNodeID))
+ {
+ err = DataModel::Decode(reader, adminNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAdminPasscodeID))
+ {
+ err = DataModel::Decode(reader, adminPasscodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kChangeType))
+ {
+ err = DataModel::Decode(reader, changeType);
+ }
+ else if (__context_tag == to_underlying(Fields::kLatestValue))
+ {
+ err = DataModel::Decode(reader, latestValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AccessControlExtensionChanged.
+namespace FabricRestrictionReviewUpdate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kToken), token));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInstruction), instruction));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kARLRequestFlowUrl), ARLRequestFlowUrl));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kToken))
+ {
+ err = DataModel::Decode(reader, token);
+ }
+ else if (__context_tag == to_underlying(Fields::kInstruction))
+ {
+ err = DataModel::Decode(reader, instruction);
+ }
+ else if (__context_tag == to_underlying(Fields::kARLRequestFlowUrl))
+ {
+ err = DataModel::Decode(reader, ARLRequestFlowUrl);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace FabricRestrictionReviewUpdate.
+} // namespace Events
+
+} // namespace AccessControl
+namespace Actions {
+namespace Structs {
+
+namespace ActionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kType), type);
+ encoder.Encode(to_underlying(Fields::kEndpointListID), endpointListID);
+ encoder.Encode(to_underlying(Fields::kSupportedCommands), supportedCommands);
+ encoder.Encode(to_underlying(Fields::kState), state);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpointListID))
+ {
+ err = DataModel::Decode(reader, endpointListID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSupportedCommands))
+ {
+ err = DataModel::Decode(reader, supportedCommands);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ActionStruct
+
+namespace EndpointListStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEndpointListID), endpointListID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kType), type);
+ encoder.Encode(to_underlying(Fields::kEndpoints), endpoints);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEndpointListID))
+ {
+ err = DataModel::Decode(reader, endpointListID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoints))
+ {
+ err = DataModel::Decode(reader, endpoints);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace EndpointListStruct
+} // namespace Structs
+
+namespace Commands {
+namespace InstantAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace InstantAction.
+namespace InstantActionWithTransition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace InstantActionWithTransition.
+namespace StartAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StartAction.
+namespace StartActionWithDuration {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StartActionWithDuration.
+namespace StopAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StopAction.
+namespace PauseAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PauseAction.
+namespace PauseActionWithDuration {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PauseActionWithDuration.
+namespace ResumeAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ResumeAction.
+namespace EnableAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnableAction.
+namespace EnableActionWithDuration {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnableActionWithDuration.
+namespace DisableAction {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DisableAction.
+namespace DisableActionWithDuration {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActionID), actionID);
+ encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DisableActionWithDuration.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::ActionList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, actionList);
+ case Attributes::EndpointLists::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, endpointLists);
+ case Attributes::SetupURL::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, setupURL);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace StateChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActionID), actionID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInvokeID), invokeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewState), newState));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kNewState))
+ {
+ err = DataModel::Decode(reader, newState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StateChanged.
+namespace ActionFailed {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActionID), actionID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInvokeID), invokeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewState), newState));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kError), error));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActionID))
+ {
+ err = DataModel::Decode(reader, actionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kInvokeID))
+ {
+ err = DataModel::Decode(reader, invokeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kNewState))
+ {
+ err = DataModel::Decode(reader, newState);
+ }
+ else if (__context_tag == to_underlying(Fields::kError))
+ {
+ err = DataModel::Decode(reader, error);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ActionFailed.
+} // namespace Events
+
+} // namespace Actions
+namespace BasicInformation {
+namespace Structs {
+
+namespace CapabilityMinimaStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCaseSessionsPerFabric), caseSessionsPerFabric);
+ encoder.Encode(to_underlying(Fields::kSubscriptionsPerFabric), subscriptionsPerFabric);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCaseSessionsPerFabric))
+ {
+ err = DataModel::Decode(reader, caseSessionsPerFabric);
+ }
+ else if (__context_tag == to_underlying(Fields::kSubscriptionsPerFabric))
+ {
+ err = DataModel::Decode(reader, subscriptionsPerFabric);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace CapabilityMinimaStruct
+
+namespace ProductAppearanceStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kFinish), finish);
+ encoder.Encode(to_underlying(Fields::kPrimaryColor), primaryColor);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFinish))
+ {
+ err = DataModel::Decode(reader, finish);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrimaryColor))
+ {
+ err = DataModel::Decode(reader, primaryColor);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProductAppearanceStruct
+} // namespace Structs
+
+namespace Commands {
+namespace MfgSpecificPing {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace MfgSpecificPing.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::DataModelRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, dataModelRevision);
+ case Attributes::VendorName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorName);
+ case Attributes::VendorID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorID);
+ case Attributes::ProductName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productName);
+ case Attributes::ProductID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productID);
+ case Attributes::NodeLabel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nodeLabel);
+ case Attributes::Location::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, location);
+ case Attributes::HardwareVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hardwareVersion);
+ case Attributes::HardwareVersionString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hardwareVersionString);
+ case Attributes::SoftwareVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, softwareVersion);
+ case Attributes::SoftwareVersionString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, softwareVersionString);
+ case Attributes::ManufacturingDate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, manufacturingDate);
+ case Attributes::PartNumber::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, partNumber);
+ case Attributes::ProductURL::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productURL);
+ case Attributes::ProductLabel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productLabel);
+ case Attributes::SerialNumber::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, serialNumber);
+ case Attributes::LocalConfigDisabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localConfigDisabled);
+ case Attributes::Reachable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, reachable);
+ case Attributes::UniqueID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uniqueID);
+ case Attributes::CapabilityMinima::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, capabilityMinima);
+ case Attributes::ProductAppearance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productAppearance);
+ case Attributes::SpecificationVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, specificationVersion);
+ case Attributes::MaxPathsPerInvoke::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxPathsPerInvoke);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace StartUp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StartUp.
+namespace ShutDown {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ShutDown.
+namespace Leave {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Leave.
+namespace ReachableChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReachableNewValue), reachableNewValue));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReachableNewValue))
+ {
+ err = DataModel::Decode(reader, reachableNewValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReachableChanged.
+} // namespace Events
+
+} // namespace BasicInformation
+namespace OtaSoftwareUpdateProvider {
+
+namespace Commands {
+namespace QueryImage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
+ encoder.Encode(to_underlying(Fields::kProductID), productID);
+ encoder.Encode(to_underlying(Fields::kSoftwareVersion), softwareVersion);
+ encoder.Encode(to_underlying(Fields::kProtocolsSupported), protocolsSupported);
+ encoder.Encode(to_underlying(Fields::kHardwareVersion), hardwareVersion);
+ encoder.Encode(to_underlying(Fields::kLocation), location);
+ encoder.Encode(to_underlying(Fields::kRequestorCanConsent), requestorCanConsent);
+ encoder.Encode(to_underlying(Fields::kMetadataForProvider), metadataForProvider);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVendorID))
+ {
+ err = DataModel::Decode(reader, vendorID);
+ }
+ else if (__context_tag == to_underlying(Fields::kProductID))
+ {
+ err = DataModel::Decode(reader, productID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else if (__context_tag == to_underlying(Fields::kProtocolsSupported))
+ {
+ err = DataModel::Decode(reader, protocolsSupported);
+ }
+ else if (__context_tag == to_underlying(Fields::kHardwareVersion))
+ {
+ err = DataModel::Decode(reader, hardwareVersion);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocation))
+ {
+ err = DataModel::Decode(reader, location);
+ }
+ else if (__context_tag == to_underlying(Fields::kRequestorCanConsent))
+ {
+ err = DataModel::Decode(reader, requestorCanConsent);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetadataForProvider))
+ {
+ err = DataModel::Decode(reader, metadataForProvider);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace QueryImage.
+namespace QueryImageResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kDelayedActionTime), delayedActionTime);
+ encoder.Encode(to_underlying(Fields::kImageURI), imageURI);
+ encoder.Encode(to_underlying(Fields::kSoftwareVersion), softwareVersion);
+ encoder.Encode(to_underlying(Fields::kSoftwareVersionString), softwareVersionString);
+ encoder.Encode(to_underlying(Fields::kUpdateToken), updateToken);
+ encoder.Encode(to_underlying(Fields::kUserConsentNeeded), userConsentNeeded);
+ encoder.Encode(to_underlying(Fields::kMetadataForRequestor), metadataForRequestor);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kDelayedActionTime))
+ {
+ err = DataModel::Decode(reader, delayedActionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kImageURI))
+ {
+ err = DataModel::Decode(reader, imageURI);
+ }
+ else if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else if (__context_tag == to_underlying(Fields::kSoftwareVersionString))
+ {
+ err = DataModel::Decode(reader, softwareVersionString);
+ }
+ else if (__context_tag == to_underlying(Fields::kUpdateToken))
+ {
+ err = DataModel::Decode(reader, updateToken);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserConsentNeeded))
+ {
+ err = DataModel::Decode(reader, userConsentNeeded);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetadataForRequestor))
+ {
+ err = DataModel::Decode(reader, metadataForRequestor);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace QueryImageResponse.
+namespace ApplyUpdateRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUpdateToken), updateToken);
+ encoder.Encode(to_underlying(Fields::kNewVersion), newVersion);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUpdateToken))
+ {
+ err = DataModel::Decode(reader, updateToken);
+ }
+ else if (__context_tag == to_underlying(Fields::kNewVersion))
+ {
+ err = DataModel::Decode(reader, newVersion);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ApplyUpdateRequest.
+namespace ApplyUpdateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAction), action);
+ encoder.Encode(to_underlying(Fields::kDelayedActionTime), delayedActionTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAction))
+ {
+ err = DataModel::Decode(reader, action);
+ }
+ else if (__context_tag == to_underlying(Fields::kDelayedActionTime))
+ {
+ err = DataModel::Decode(reader, delayedActionTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ApplyUpdateResponse.
+namespace NotifyUpdateApplied {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUpdateToken), updateToken);
+ encoder.Encode(to_underlying(Fields::kSoftwareVersion), softwareVersion);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUpdateToken))
+ {
+ err = DataModel::Decode(reader, updateToken);
+ }
+ else if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NotifyUpdateApplied.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace OtaSoftwareUpdateProvider
+namespace OtaSoftwareUpdateRequestor {
+namespace Structs {
+
+namespace ProviderLocation {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ encoder.Encode(to_underlying(Fields::kProviderNodeID), providerNodeID);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProviderNodeID))
+ {
+ err = DataModel::Decode(reader, providerNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProviderLocation
+} // namespace Structs
+
+namespace Commands {
+namespace AnnounceOTAProvider {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProviderNodeID), providerNodeID);
+ encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
+ encoder.Encode(to_underlying(Fields::kAnnouncementReason), announcementReason);
+ encoder.Encode(to_underlying(Fields::kMetadataForNode), metadataForNode);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProviderNodeID))
+ {
+ err = DataModel::Decode(reader, providerNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kVendorID))
+ {
+ err = DataModel::Decode(reader, vendorID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAnnouncementReason))
+ {
+ err = DataModel::Decode(reader, announcementReason);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetadataForNode))
+ {
+ err = DataModel::Decode(reader, metadataForNode);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AnnounceOTAProvider.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::DefaultOTAProviders::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultOTAProviders);
+ case Attributes::UpdatePossible::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, updatePossible);
+ case Attributes::UpdateState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, updateState);
+ case Attributes::UpdateStateProgress::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, updateStateProgress);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace StateTransition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousState), previousState));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewState), newState));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTargetSoftwareVersion), targetSoftwareVersion));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPreviousState))
+ {
+ err = DataModel::Decode(reader, previousState);
+ }
+ else if (__context_tag == to_underlying(Fields::kNewState))
+ {
+ err = DataModel::Decode(reader, newState);
+ }
+ else if (__context_tag == to_underlying(Fields::kReason))
+ {
+ err = DataModel::Decode(reader, reason);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargetSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, targetSoftwareVersion);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StateTransition.
+namespace VersionApplied {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kProductID), productID));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else if (__context_tag == to_underlying(Fields::kProductID))
+ {
+ err = DataModel::Decode(reader, productID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace VersionApplied.
+namespace DownloadError {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBytesDownloaded), bytesDownloaded));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kProgressPercent), progressPercent));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPlatformCode), platformCode));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else if (__context_tag == to_underlying(Fields::kBytesDownloaded))
+ {
+ err = DataModel::Decode(reader, bytesDownloaded);
+ }
+ else if (__context_tag == to_underlying(Fields::kProgressPercent))
+ {
+ err = DataModel::Decode(reader, progressPercent);
+ }
+ else if (__context_tag == to_underlying(Fields::kPlatformCode))
+ {
+ err = DataModel::Decode(reader, platformCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DownloadError.
+} // namespace Events
+
+} // namespace OtaSoftwareUpdateRequestor
+namespace LocalizationConfiguration {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::ActiveLocale::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeLocale);
+ case Attributes::SupportedLocales::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedLocales);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace LocalizationConfiguration
+namespace TimeFormatLocalization {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::HourFormat::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hourFormat);
+ case Attributes::ActiveCalendarType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeCalendarType);
+ case Attributes::SupportedCalendarTypes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedCalendarTypes);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace TimeFormatLocalization
+namespace UnitLocalization {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::TemperatureUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, temperatureUnit);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace UnitLocalization
+namespace PowerSourceConfiguration {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Sources::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sources);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace PowerSourceConfiguration
+namespace PowerSource {
+namespace Structs {
+
+namespace BatChargeFaultChangeType {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCurrent), current);
+ encoder.Encode(to_underlying(Fields::kPrevious), previous);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace BatChargeFaultChangeType
+
+namespace BatFaultChangeType {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCurrent), current);
+ encoder.Encode(to_underlying(Fields::kPrevious), previous);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace BatFaultChangeType
+
+namespace WiredFaultChangeType {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCurrent), current);
+ encoder.Encode(to_underlying(Fields::kPrevious), previous);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace WiredFaultChangeType
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Status::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, status);
+ case Attributes::Order::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, order);
+ case Attributes::Description::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, description);
+ case Attributes::WiredAssessedInputVoltage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredAssessedInputVoltage);
+ case Attributes::WiredAssessedInputFrequency::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredAssessedInputFrequency);
+ case Attributes::WiredCurrentType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredCurrentType);
+ case Attributes::WiredAssessedCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredAssessedCurrent);
+ case Attributes::WiredNominalVoltage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredNominalVoltage);
+ case Attributes::WiredMaximumCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredMaximumCurrent);
+ case Attributes::WiredPresent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiredPresent);
+ case Attributes::ActiveWiredFaults::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeWiredFaults);
+ case Attributes::BatVoltage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batVoltage);
+ case Attributes::BatPercentRemaining::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batPercentRemaining);
+ case Attributes::BatTimeRemaining::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batTimeRemaining);
+ case Attributes::BatChargeLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batChargeLevel);
+ case Attributes::BatReplacementNeeded::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batReplacementNeeded);
+ case Attributes::BatReplaceability::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batReplaceability);
+ case Attributes::BatPresent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batPresent);
+ case Attributes::ActiveBatFaults::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeBatFaults);
+ case Attributes::BatReplacementDescription::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batReplacementDescription);
+ case Attributes::BatCommonDesignation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batCommonDesignation);
+ case Attributes::BatANSIDesignation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batANSIDesignation);
+ case Attributes::BatIECDesignation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batIECDesignation);
+ case Attributes::BatApprovedChemistry::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batApprovedChemistry);
+ case Attributes::BatCapacity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batCapacity);
+ case Attributes::BatQuantity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batQuantity);
+ case Attributes::BatChargeState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batChargeState);
+ case Attributes::BatTimeToFullCharge::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batTimeToFullCharge);
+ case Attributes::BatFunctionalWhileCharging::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batFunctionalWhileCharging);
+ case Attributes::BatChargingCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batChargingCurrent);
+ case Attributes::ActiveBatChargeFaults::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeBatChargeFaults);
+ case Attributes::EndpointList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, endpointList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace WiredFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace WiredFaultChange.
+namespace BatFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace BatFaultChange.
+namespace BatChargeFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace BatChargeFaultChange.
+} // namespace Events
+
+} // namespace PowerSource
+namespace GeneralCommissioning {
+namespace Structs {
+
+namespace BasicCommissioningInfo {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kFailSafeExpiryLengthSeconds), failSafeExpiryLengthSeconds);
+ encoder.Encode(to_underlying(Fields::kMaxCumulativeFailsafeSeconds), maxCumulativeFailsafeSeconds);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFailSafeExpiryLengthSeconds))
+ {
+ err = DataModel::Decode(reader, failSafeExpiryLengthSeconds);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxCumulativeFailsafeSeconds))
+ {
+ err = DataModel::Decode(reader, maxCumulativeFailsafeSeconds);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace BasicCommissioningInfo
+} // namespace Structs
+
+namespace Commands {
+namespace ArmFailSafe {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kExpiryLengthSeconds), expiryLengthSeconds);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kExpiryLengthSeconds))
+ {
+ err = DataModel::Decode(reader, expiryLengthSeconds);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ArmFailSafe.
+namespace ArmFailSafeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorCode))
+ {
+ err = DataModel::Decode(reader, errorCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ArmFailSafeResponse.
+namespace SetRegulatoryConfig {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewRegulatoryConfig), newRegulatoryConfig);
+ encoder.Encode(to_underlying(Fields::kCountryCode), countryCode);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewRegulatoryConfig))
+ {
+ err = DataModel::Decode(reader, newRegulatoryConfig);
+ }
+ else if (__context_tag == to_underlying(Fields::kCountryCode))
+ {
+ err = DataModel::Decode(reader, countryCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetRegulatoryConfig.
+namespace SetRegulatoryConfigResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorCode))
+ {
+ err = DataModel::Decode(reader, errorCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetRegulatoryConfigResponse.
+namespace CommissioningComplete {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace CommissioningComplete.
+namespace CommissioningCompleteResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorCode))
+ {
+ err = DataModel::Decode(reader, errorCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CommissioningCompleteResponse.
+namespace SetTCAcknowledgements {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTCVersion), TCVersion);
+ encoder.Encode(to_underlying(Fields::kTCUserResponse), TCUserResponse);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTCVersion))
+ {
+ err = DataModel::Decode(reader, TCVersion);
+ }
+ else if (__context_tag == to_underlying(Fields::kTCUserResponse))
+ {
+ err = DataModel::Decode(reader, TCUserResponse);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTCAcknowledgements.
+namespace SetTCAcknowledgementsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorCode))
+ {
+ err = DataModel::Decode(reader, errorCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTCAcknowledgementsResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Breadcrumb::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, breadcrumb);
+ case Attributes::BasicCommissioningInfo::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, basicCommissioningInfo);
+ case Attributes::RegulatoryConfig::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, regulatoryConfig);
+ case Attributes::LocationCapability::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, locationCapability);
+ case Attributes::SupportsConcurrentConnection::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportsConcurrentConnection);
+ case Attributes::TCAcceptedVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, TCAcceptedVersion);
+ case Attributes::TCMinRequiredVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, TCMinRequiredVersion);
+ case Attributes::TCAcknowledgements::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, TCAcknowledgements);
+ case Attributes::TCAcknowledgementsRequired::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, TCAcknowledgementsRequired);
+ case Attributes::TCUpdateDeadline::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, TCUpdateDeadline);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace GeneralCommissioning
+namespace NetworkCommissioning {
+namespace Structs {
+
+namespace NetworkInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
+ encoder.Encode(to_underlying(Fields::kConnected), connected);
+ encoder.Encode(to_underlying(Fields::kNetworkIdentifier), networkIdentifier);
+ encoder.Encode(to_underlying(Fields::kClientIdentifier), clientIdentifier);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkID))
+ {
+ err = DataModel::Decode(reader, networkID);
+ }
+ else if (__context_tag == to_underlying(Fields::kConnected))
+ {
+ err = DataModel::Decode(reader, connected);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkIdentifier))
+ {
+ err = DataModel::Decode(reader, networkIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kClientIdentifier))
+ {
+ err = DataModel::Decode(reader, clientIdentifier);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NetworkInfoStruct
+
+namespace ThreadInterfaceScanResultStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPanId), panId);
+ encoder.Encode(to_underlying(Fields::kExtendedPanId), extendedPanId);
+ encoder.Encode(to_underlying(Fields::kNetworkName), networkName);
+ encoder.Encode(to_underlying(Fields::kChannel), channel);
+ encoder.Encode(to_underlying(Fields::kVersion), version);
+ encoder.Encode(to_underlying(Fields::kExtendedAddress), extendedAddress);
+ encoder.Encode(to_underlying(Fields::kRssi), rssi);
+ encoder.Encode(to_underlying(Fields::kLqi), lqi);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPanId))
+ {
+ err = DataModel::Decode(reader, panId);
+ }
+ else if (__context_tag == to_underlying(Fields::kExtendedPanId))
+ {
+ err = DataModel::Decode(reader, extendedPanId);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkName))
+ {
+ err = DataModel::Decode(reader, networkName);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannel))
+ {
+ err = DataModel::Decode(reader, channel);
+ }
+ else if (__context_tag == to_underlying(Fields::kVersion))
+ {
+ err = DataModel::Decode(reader, version);
+ }
+ else if (__context_tag == to_underlying(Fields::kExtendedAddress))
+ {
+ err = DataModel::Decode(reader, extendedAddress);
+ }
+ else if (__context_tag == to_underlying(Fields::kRssi))
+ {
+ err = DataModel::Decode(reader, rssi);
+ }
+ else if (__context_tag == to_underlying(Fields::kLqi))
+ {
+ err = DataModel::Decode(reader, lqi);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ThreadInterfaceScanResultStruct
+
+namespace WiFiInterfaceScanResultStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSecurity), security);
+ encoder.Encode(to_underlying(Fields::kSsid), ssid);
+ encoder.Encode(to_underlying(Fields::kBssid), bssid);
+ encoder.Encode(to_underlying(Fields::kChannel), channel);
+ encoder.Encode(to_underlying(Fields::kWiFiBand), wiFiBand);
+ encoder.Encode(to_underlying(Fields::kRssi), rssi);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSecurity))
+ {
+ err = DataModel::Decode(reader, security);
+ }
+ else if (__context_tag == to_underlying(Fields::kSsid))
+ {
+ err = DataModel::Decode(reader, ssid);
+ }
+ else if (__context_tag == to_underlying(Fields::kBssid))
+ {
+ err = DataModel::Decode(reader, bssid);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannel))
+ {
+ err = DataModel::Decode(reader, channel);
+ }
+ else if (__context_tag == to_underlying(Fields::kWiFiBand))
+ {
+ err = DataModel::Decode(reader, wiFiBand);
+ }
+ else if (__context_tag == to_underlying(Fields::kRssi))
+ {
+ err = DataModel::Decode(reader, rssi);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace WiFiInterfaceScanResultStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ScanNetworks {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSsid), ssid);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSsid))
+ {
+ err = DataModel::Decode(reader, ssid);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ScanNetworks.
+namespace ScanNetworksResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkingStatus), networkingStatus);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ encoder.Encode(to_underlying(Fields::kWiFiScanResults), wiFiScanResults);
+ encoder.Encode(to_underlying(Fields::kThreadScanResults), threadScanResults);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkingStatus))
+ {
+ err = DataModel::Decode(reader, networkingStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else if (__context_tag == to_underlying(Fields::kWiFiScanResults))
+ {
+ err = DataModel::Decode(reader, wiFiScanResults);
+ }
+ else if (__context_tag == to_underlying(Fields::kThreadScanResults))
+ {
+ err = DataModel::Decode(reader, threadScanResults);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ScanNetworksResponse.
+namespace AddOrUpdateWiFiNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSsid), ssid);
+ encoder.Encode(to_underlying(Fields::kCredentials), credentials);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ encoder.Encode(to_underlying(Fields::kNetworkIdentity), networkIdentity);
+ encoder.Encode(to_underlying(Fields::kClientIdentifier), clientIdentifier);
+ encoder.Encode(to_underlying(Fields::kPossessionNonce), possessionNonce);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSsid))
+ {
+ err = DataModel::Decode(reader, ssid);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentials))
+ {
+ err = DataModel::Decode(reader, credentials);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkIdentity))
+ {
+ err = DataModel::Decode(reader, networkIdentity);
+ }
+ else if (__context_tag == to_underlying(Fields::kClientIdentifier))
+ {
+ err = DataModel::Decode(reader, clientIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kPossessionNonce))
+ {
+ err = DataModel::Decode(reader, possessionNonce);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddOrUpdateWiFiNetwork.
+namespace AddOrUpdateThreadNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperationalDataset), operationalDataset);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperationalDataset))
+ {
+ err = DataModel::Decode(reader, operationalDataset);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddOrUpdateThreadNetwork.
+namespace RemoveNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkID))
+ {
+ err = DataModel::Decode(reader, networkID);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveNetwork.
+namespace NetworkConfigResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkingStatus), networkingStatus);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ encoder.Encode(to_underlying(Fields::kNetworkIndex), networkIndex);
+ encoder.Encode(to_underlying(Fields::kClientIdentity), clientIdentity);
+ encoder.Encode(to_underlying(Fields::kPossessionSignature), possessionSignature);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkingStatus))
+ {
+ err = DataModel::Decode(reader, networkingStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkIndex))
+ {
+ err = DataModel::Decode(reader, networkIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kClientIdentity))
+ {
+ err = DataModel::Decode(reader, clientIdentity);
+ }
+ else if (__context_tag == to_underlying(Fields::kPossessionSignature))
+ {
+ err = DataModel::Decode(reader, possessionSignature);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NetworkConfigResponse.
+namespace ConnectNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkID))
+ {
+ err = DataModel::Decode(reader, networkID);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ConnectNetwork.
+namespace ConnectNetworkResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkingStatus), networkingStatus);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ encoder.Encode(to_underlying(Fields::kErrorValue), errorValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkingStatus))
+ {
+ err = DataModel::Decode(reader, networkingStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else if (__context_tag == to_underlying(Fields::kErrorValue))
+ {
+ err = DataModel::Decode(reader, errorValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ConnectNetworkResponse.
+namespace ReorderNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
+ encoder.Encode(to_underlying(Fields::kNetworkIndex), networkIndex);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNetworkID))
+ {
+ err = DataModel::Decode(reader, networkID);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkIndex))
+ {
+ err = DataModel::Decode(reader, networkIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReorderNetwork.
+namespace QueryIdentity {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kKeyIdentifier), keyIdentifier);
+ encoder.Encode(to_underlying(Fields::kPossessionNonce), possessionNonce);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kKeyIdentifier))
+ {
+ err = DataModel::Decode(reader, keyIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kPossessionNonce))
+ {
+ err = DataModel::Decode(reader, possessionNonce);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace QueryIdentity.
+namespace QueryIdentityResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIdentity), identity);
+ encoder.Encode(to_underlying(Fields::kPossessionSignature), possessionSignature);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIdentity))
+ {
+ err = DataModel::Decode(reader, identity);
+ }
+ else if (__context_tag == to_underlying(Fields::kPossessionSignature))
+ {
+ err = DataModel::Decode(reader, possessionSignature);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace QueryIdentityResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MaxNetworks::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxNetworks);
+ case Attributes::Networks::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, networks);
+ case Attributes::ScanMaxTimeSeconds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scanMaxTimeSeconds);
+ case Attributes::ConnectMaxTimeSeconds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, connectMaxTimeSeconds);
+ case Attributes::InterfaceEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, interfaceEnabled);
+ case Attributes::LastNetworkingStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lastNetworkingStatus);
+ case Attributes::LastNetworkID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lastNetworkID);
+ case Attributes::LastConnectErrorValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lastConnectErrorValue);
+ case Attributes::SupportedWiFiBands::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedWiFiBands);
+ case Attributes::SupportedThreadFeatures::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedThreadFeatures);
+ case Attributes::ThreadVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, threadVersion);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace NetworkCommissioning
+namespace DiagnosticLogs {
+
+namespace Commands {
+namespace RetrieveLogsRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIntent), intent);
+ encoder.Encode(to_underlying(Fields::kRequestedProtocol), requestedProtocol);
+ encoder.Encode(to_underlying(Fields::kTransferFileDesignator), transferFileDesignator);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIntent))
+ {
+ err = DataModel::Decode(reader, intent);
+ }
+ else if (__context_tag == to_underlying(Fields::kRequestedProtocol))
+ {
+ err = DataModel::Decode(reader, requestedProtocol);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransferFileDesignator))
+ {
+ err = DataModel::Decode(reader, transferFileDesignator);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RetrieveLogsRequest.
+namespace RetrieveLogsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kLogContent), logContent);
+ encoder.Encode(to_underlying(Fields::kUTCTimeStamp), UTCTimeStamp);
+ encoder.Encode(to_underlying(Fields::kTimeSinceBoot), timeSinceBoot);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kLogContent))
+ {
+ err = DataModel::Decode(reader, logContent);
+ }
+ else if (__context_tag == to_underlying(Fields::kUTCTimeStamp))
+ {
+ err = DataModel::Decode(reader, UTCTimeStamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kTimeSinceBoot))
+ {
+ err = DataModel::Decode(reader, timeSinceBoot);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RetrieveLogsResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace DiagnosticLogs
+namespace GeneralDiagnostics {
+namespace Structs {
+
+namespace NetworkInterface {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kIsOperational), isOperational);
+ encoder.Encode(to_underlying(Fields::kOffPremiseServicesReachableIPv4), offPremiseServicesReachableIPv4);
+ encoder.Encode(to_underlying(Fields::kOffPremiseServicesReachableIPv6), offPremiseServicesReachableIPv6);
+ encoder.Encode(to_underlying(Fields::kHardwareAddress), hardwareAddress);
+ encoder.Encode(to_underlying(Fields::kIPv4Addresses), IPv4Addresses);
+ encoder.Encode(to_underlying(Fields::kIPv6Addresses), IPv6Addresses);
+ encoder.Encode(to_underlying(Fields::kType), type);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kIsOperational))
+ {
+ err = DataModel::Decode(reader, isOperational);
+ }
+ else if (__context_tag == to_underlying(Fields::kOffPremiseServicesReachableIPv4))
+ {
+ err = DataModel::Decode(reader, offPremiseServicesReachableIPv4);
+ }
+ else if (__context_tag == to_underlying(Fields::kOffPremiseServicesReachableIPv6))
+ {
+ err = DataModel::Decode(reader, offPremiseServicesReachableIPv6);
+ }
+ else if (__context_tag == to_underlying(Fields::kHardwareAddress))
+ {
+ err = DataModel::Decode(reader, hardwareAddress);
+ }
+ else if (__context_tag == to_underlying(Fields::kIPv4Addresses))
+ {
+ err = DataModel::Decode(reader, IPv4Addresses);
+ }
+ else if (__context_tag == to_underlying(Fields::kIPv6Addresses))
+ {
+ err = DataModel::Decode(reader, IPv6Addresses);
+ }
+ else if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NetworkInterface
+} // namespace Structs
+
+namespace Commands {
+namespace TestEventTrigger {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEnableKey), enableKey);
+ encoder.Encode(to_underlying(Fields::kEventTrigger), eventTrigger);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnableKey))
+ {
+ err = DataModel::Decode(reader, enableKey);
+ }
+ else if (__context_tag == to_underlying(Fields::kEventTrigger))
+ {
+ err = DataModel::Decode(reader, eventTrigger);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEventTrigger.
+namespace TimeSnapshot {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TimeSnapshot.
+namespace TimeSnapshotResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSystemTimeMs), systemTimeMs);
+ encoder.Encode(to_underlying(Fields::kPosixTimeMs), posixTimeMs);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSystemTimeMs))
+ {
+ err = DataModel::Decode(reader, systemTimeMs);
+ }
+ else if (__context_tag == to_underlying(Fields::kPosixTimeMs))
+ {
+ err = DataModel::Decode(reader, posixTimeMs);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TimeSnapshotResponse.
+namespace PayloadTestRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEnableKey), enableKey);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ encoder.Encode(to_underlying(Fields::kCount), count);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnableKey))
+ {
+ err = DataModel::Decode(reader, enableKey);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else if (__context_tag == to_underlying(Fields::kCount))
+ {
+ err = DataModel::Decode(reader, count);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PayloadTestRequest.
+namespace PayloadTestResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPayload), payload);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPayload))
+ {
+ err = DataModel::Decode(reader, payload);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PayloadTestResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::NetworkInterfaces::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, networkInterfaces);
+ case Attributes::RebootCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rebootCount);
+ case Attributes::UpTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, upTime);
+ case Attributes::TotalOperationalHours::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, totalOperationalHours);
+ case Attributes::BootReason::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, bootReason);
+ case Attributes::ActiveHardwareFaults::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeHardwareFaults);
+ case Attributes::ActiveRadioFaults::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeRadioFaults);
+ case Attributes::ActiveNetworkFaults::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeNetworkFaults);
+ case Attributes::TestEventTriggersEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, testEventTriggersEnabled);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace HardwareFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace HardwareFaultChange.
+namespace RadioFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RadioFaultChange.
+namespace NetworkFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NetworkFaultChange.
+namespace BootReason {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBootReason), bootReason));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kBootReason))
+ {
+ err = DataModel::Decode(reader, bootReason);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace BootReason.
+} // namespace Events
+
+} // namespace GeneralDiagnostics
+namespace SoftwareDiagnostics {
+namespace Structs {
+
+namespace ThreadMetricsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kId), id);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kStackFreeCurrent), stackFreeCurrent);
+ encoder.Encode(to_underlying(Fields::kStackFreeMinimum), stackFreeMinimum);
+ encoder.Encode(to_underlying(Fields::kStackSize), stackSize);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kStackFreeCurrent))
+ {
+ err = DataModel::Decode(reader, stackFreeCurrent);
+ }
+ else if (__context_tag == to_underlying(Fields::kStackFreeMinimum))
+ {
+ err = DataModel::Decode(reader, stackFreeMinimum);
+ }
+ else if (__context_tag == to_underlying(Fields::kStackSize))
+ {
+ err = DataModel::Decode(reader, stackSize);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ThreadMetricsStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ResetWatermarks {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetWatermarks.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::ThreadMetrics::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, threadMetrics);
+ case Attributes::CurrentHeapFree::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentHeapFree);
+ case Attributes::CurrentHeapUsed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentHeapUsed);
+ case Attributes::CurrentHeapHighWatermark::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentHeapHighWatermark);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace SoftwareFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kId), id));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kName), name));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultRecording), faultRecording));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kFaultRecording))
+ {
+ err = DataModel::Decode(reader, faultRecording);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SoftwareFault.
+} // namespace Events
+
+} // namespace SoftwareDiagnostics
+namespace ThreadNetworkDiagnostics {
+namespace Structs {
+
+namespace NeighborTableStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kExtAddress), extAddress);
+ encoder.Encode(to_underlying(Fields::kAge), age);
+ encoder.Encode(to_underlying(Fields::kRloc16), rloc16);
+ encoder.Encode(to_underlying(Fields::kLinkFrameCounter), linkFrameCounter);
+ encoder.Encode(to_underlying(Fields::kMleFrameCounter), mleFrameCounter);
+ encoder.Encode(to_underlying(Fields::kLqi), lqi);
+ encoder.Encode(to_underlying(Fields::kAverageRssi), averageRssi);
+ encoder.Encode(to_underlying(Fields::kLastRssi), lastRssi);
+ encoder.Encode(to_underlying(Fields::kFrameErrorRate), frameErrorRate);
+ encoder.Encode(to_underlying(Fields::kMessageErrorRate), messageErrorRate);
+ encoder.Encode(to_underlying(Fields::kRxOnWhenIdle), rxOnWhenIdle);
+ encoder.Encode(to_underlying(Fields::kFullThreadDevice), fullThreadDevice);
+ encoder.Encode(to_underlying(Fields::kFullNetworkData), fullNetworkData);
+ encoder.Encode(to_underlying(Fields::kIsChild), isChild);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kExtAddress))
+ {
+ err = DataModel::Decode(reader, extAddress);
+ }
+ else if (__context_tag == to_underlying(Fields::kAge))
+ {
+ err = DataModel::Decode(reader, age);
+ }
+ else if (__context_tag == to_underlying(Fields::kRloc16))
+ {
+ err = DataModel::Decode(reader, rloc16);
+ }
+ else if (__context_tag == to_underlying(Fields::kLinkFrameCounter))
+ {
+ err = DataModel::Decode(reader, linkFrameCounter);
+ }
+ else if (__context_tag == to_underlying(Fields::kMleFrameCounter))
+ {
+ err = DataModel::Decode(reader, mleFrameCounter);
+ }
+ else if (__context_tag == to_underlying(Fields::kLqi))
+ {
+ err = DataModel::Decode(reader, lqi);
+ }
+ else if (__context_tag == to_underlying(Fields::kAverageRssi))
+ {
+ err = DataModel::Decode(reader, averageRssi);
+ }
+ else if (__context_tag == to_underlying(Fields::kLastRssi))
+ {
+ err = DataModel::Decode(reader, lastRssi);
+ }
+ else if (__context_tag == to_underlying(Fields::kFrameErrorRate))
+ {
+ err = DataModel::Decode(reader, frameErrorRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMessageErrorRate))
+ {
+ err = DataModel::Decode(reader, messageErrorRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kRxOnWhenIdle))
+ {
+ err = DataModel::Decode(reader, rxOnWhenIdle);
+ }
+ else if (__context_tag == to_underlying(Fields::kFullThreadDevice))
+ {
+ err = DataModel::Decode(reader, fullThreadDevice);
+ }
+ else if (__context_tag == to_underlying(Fields::kFullNetworkData))
+ {
+ err = DataModel::Decode(reader, fullNetworkData);
+ }
+ else if (__context_tag == to_underlying(Fields::kIsChild))
+ {
+ err = DataModel::Decode(reader, isChild);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NeighborTableStruct
+
+namespace OperationalDatasetComponents {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActiveTimestampPresent), activeTimestampPresent);
+ encoder.Encode(to_underlying(Fields::kPendingTimestampPresent), pendingTimestampPresent);
+ encoder.Encode(to_underlying(Fields::kMasterKeyPresent), masterKeyPresent);
+ encoder.Encode(to_underlying(Fields::kNetworkNamePresent), networkNamePresent);
+ encoder.Encode(to_underlying(Fields::kExtendedPanIdPresent), extendedPanIdPresent);
+ encoder.Encode(to_underlying(Fields::kMeshLocalPrefixPresent), meshLocalPrefixPresent);
+ encoder.Encode(to_underlying(Fields::kDelayPresent), delayPresent);
+ encoder.Encode(to_underlying(Fields::kPanIdPresent), panIdPresent);
+ encoder.Encode(to_underlying(Fields::kChannelPresent), channelPresent);
+ encoder.Encode(to_underlying(Fields::kPskcPresent), pskcPresent);
+ encoder.Encode(to_underlying(Fields::kSecurityPolicyPresent), securityPolicyPresent);
+ encoder.Encode(to_underlying(Fields::kChannelMaskPresent), channelMaskPresent);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActiveTimestampPresent))
+ {
+ err = DataModel::Decode(reader, activeTimestampPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kPendingTimestampPresent))
+ {
+ err = DataModel::Decode(reader, pendingTimestampPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kMasterKeyPresent))
+ {
+ err = DataModel::Decode(reader, masterKeyPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkNamePresent))
+ {
+ err = DataModel::Decode(reader, networkNamePresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kExtendedPanIdPresent))
+ {
+ err = DataModel::Decode(reader, extendedPanIdPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kMeshLocalPrefixPresent))
+ {
+ err = DataModel::Decode(reader, meshLocalPrefixPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kDelayPresent))
+ {
+ err = DataModel::Decode(reader, delayPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kPanIdPresent))
+ {
+ err = DataModel::Decode(reader, panIdPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannelPresent))
+ {
+ err = DataModel::Decode(reader, channelPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kPskcPresent))
+ {
+ err = DataModel::Decode(reader, pskcPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kSecurityPolicyPresent))
+ {
+ err = DataModel::Decode(reader, securityPolicyPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannelMaskPresent))
+ {
+ err = DataModel::Decode(reader, channelMaskPresent);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace OperationalDatasetComponents
+
+namespace RouteTableStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kExtAddress), extAddress);
+ encoder.Encode(to_underlying(Fields::kRloc16), rloc16);
+ encoder.Encode(to_underlying(Fields::kRouterId), routerId);
+ encoder.Encode(to_underlying(Fields::kNextHop), nextHop);
+ encoder.Encode(to_underlying(Fields::kPathCost), pathCost);
+ encoder.Encode(to_underlying(Fields::kLQIIn), LQIIn);
+ encoder.Encode(to_underlying(Fields::kLQIOut), LQIOut);
+ encoder.Encode(to_underlying(Fields::kAge), age);
+ encoder.Encode(to_underlying(Fields::kAllocated), allocated);
+ encoder.Encode(to_underlying(Fields::kLinkEstablished), linkEstablished);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kExtAddress))
+ {
+ err = DataModel::Decode(reader, extAddress);
+ }
+ else if (__context_tag == to_underlying(Fields::kRloc16))
+ {
+ err = DataModel::Decode(reader, rloc16);
+ }
+ else if (__context_tag == to_underlying(Fields::kRouterId))
+ {
+ err = DataModel::Decode(reader, routerId);
+ }
+ else if (__context_tag == to_underlying(Fields::kNextHop))
+ {
+ err = DataModel::Decode(reader, nextHop);
+ }
+ else if (__context_tag == to_underlying(Fields::kPathCost))
+ {
+ err = DataModel::Decode(reader, pathCost);
+ }
+ else if (__context_tag == to_underlying(Fields::kLQIIn))
+ {
+ err = DataModel::Decode(reader, LQIIn);
+ }
+ else if (__context_tag == to_underlying(Fields::kLQIOut))
+ {
+ err = DataModel::Decode(reader, LQIOut);
+ }
+ else if (__context_tag == to_underlying(Fields::kAge))
+ {
+ err = DataModel::Decode(reader, age);
+ }
+ else if (__context_tag == to_underlying(Fields::kAllocated))
+ {
+ err = DataModel::Decode(reader, allocated);
+ }
+ else if (__context_tag == to_underlying(Fields::kLinkEstablished))
+ {
+ err = DataModel::Decode(reader, linkEstablished);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace RouteTableStruct
+
+namespace SecurityPolicy {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRotationTime), rotationTime);
+ encoder.Encode(to_underlying(Fields::kFlags), flags);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRotationTime))
+ {
+ err = DataModel::Decode(reader, rotationTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kFlags))
+ {
+ err = DataModel::Decode(reader, flags);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SecurityPolicy
+} // namespace Structs
+
+namespace Commands {
+namespace ResetCounts {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetCounts.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Channel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, channel);
+ case Attributes::RoutingRole::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, routingRole);
+ case Attributes::NetworkName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, networkName);
+ case Attributes::PanId::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, panId);
+ case Attributes::ExtendedPanId::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, extendedPanId);
+ case Attributes::MeshLocalPrefix::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, meshLocalPrefix);
+ case Attributes::OverrunCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, overrunCount);
+ case Attributes::NeighborTable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, neighborTable);
+ case Attributes::RouteTable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, routeTable);
+ case Attributes::PartitionId::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, partitionId);
+ case Attributes::Weighting::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, weighting);
+ case Attributes::DataVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, dataVersion);
+ case Attributes::StableDataVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, stableDataVersion);
+ case Attributes::LeaderRouterId::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, leaderRouterId);
+ case Attributes::DetachedRoleCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, detachedRoleCount);
+ case Attributes::ChildRoleCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, childRoleCount);
+ case Attributes::RouterRoleCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, routerRoleCount);
+ case Attributes::LeaderRoleCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, leaderRoleCount);
+ case Attributes::AttachAttemptCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attachAttemptCount);
+ case Attributes::PartitionIdChangeCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, partitionIdChangeCount);
+ case Attributes::BetterPartitionAttachAttemptCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, betterPartitionAttachAttemptCount);
+ case Attributes::ParentChangeCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, parentChangeCount);
+ case Attributes::TxTotalCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txTotalCount);
+ case Attributes::TxUnicastCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txUnicastCount);
+ case Attributes::TxBroadcastCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txBroadcastCount);
+ case Attributes::TxAckRequestedCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txAckRequestedCount);
+ case Attributes::TxAckedCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txAckedCount);
+ case Attributes::TxNoAckRequestedCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txNoAckRequestedCount);
+ case Attributes::TxDataCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txDataCount);
+ case Attributes::TxDataPollCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txDataPollCount);
+ case Attributes::TxBeaconCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txBeaconCount);
+ case Attributes::TxBeaconRequestCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txBeaconRequestCount);
+ case Attributes::TxOtherCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txOtherCount);
+ case Attributes::TxRetryCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txRetryCount);
+ case Attributes::TxDirectMaxRetryExpiryCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txDirectMaxRetryExpiryCount);
+ case Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txIndirectMaxRetryExpiryCount);
+ case Attributes::TxErrCcaCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txErrCcaCount);
+ case Attributes::TxErrAbortCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txErrAbortCount);
+ case Attributes::TxErrBusyChannelCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txErrBusyChannelCount);
+ case Attributes::RxTotalCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxTotalCount);
+ case Attributes::RxUnicastCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxUnicastCount);
+ case Attributes::RxBroadcastCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxBroadcastCount);
+ case Attributes::RxDataCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxDataCount);
+ case Attributes::RxDataPollCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxDataPollCount);
+ case Attributes::RxBeaconCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxBeaconCount);
+ case Attributes::RxBeaconRequestCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxBeaconRequestCount);
+ case Attributes::RxOtherCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxOtherCount);
+ case Attributes::RxAddressFilteredCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxAddressFilteredCount);
+ case Attributes::RxDestAddrFilteredCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxDestAddrFilteredCount);
+ case Attributes::RxDuplicatedCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxDuplicatedCount);
+ case Attributes::RxErrNoFrameCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxErrNoFrameCount);
+ case Attributes::RxErrUnknownNeighborCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxErrUnknownNeighborCount);
+ case Attributes::RxErrInvalidSrcAddrCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxErrInvalidSrcAddrCount);
+ case Attributes::RxErrSecCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxErrSecCount);
+ case Attributes::RxErrFcsCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxErrFcsCount);
+ case Attributes::RxErrOtherCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rxErrOtherCount);
+ case Attributes::ActiveTimestamp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeTimestamp);
+ case Attributes::PendingTimestamp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, pendingTimestamp);
+ case Attributes::Delay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, delay);
+ case Attributes::SecurityPolicy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, securityPolicy);
+ case Attributes::ChannelPage0Mask::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, channelPage0Mask);
+ case Attributes::OperationalDatasetComponents::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalDatasetComponents);
+ case Attributes::ActiveNetworkFaultsList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeNetworkFaultsList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace ConnectionStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kConnectionStatus), connectionStatus));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kConnectionStatus))
+ {
+ err = DataModel::Decode(reader, connectionStatus);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ConnectionStatus.
+namespace NetworkFaultChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrent))
+ {
+ err = DataModel::Decode(reader, current);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrevious))
+ {
+ err = DataModel::Decode(reader, previous);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NetworkFaultChange.
+} // namespace Events
+
+} // namespace ThreadNetworkDiagnostics
+namespace WiFiNetworkDiagnostics {
+
+namespace Commands {
+namespace ResetCounts {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetCounts.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Bssid::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, bssid);
+ case Attributes::SecurityType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, securityType);
+ case Attributes::WiFiVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wiFiVersion);
+ case Attributes::ChannelNumber::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, channelNumber);
+ case Attributes::Rssi::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rssi);
+ case Attributes::BeaconLostCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, beaconLostCount);
+ case Attributes::BeaconRxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, beaconRxCount);
+ case Attributes::PacketMulticastRxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, packetMulticastRxCount);
+ case Attributes::PacketMulticastTxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, packetMulticastTxCount);
+ case Attributes::PacketUnicastRxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, packetUnicastRxCount);
+ case Attributes::PacketUnicastTxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, packetUnicastTxCount);
+ case Attributes::CurrentMaxRate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMaxRate);
+ case Attributes::OverrunCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, overrunCount);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace Disconnection {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReasonCode), reasonCode));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReasonCode))
+ {
+ err = DataModel::Decode(reader, reasonCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Disconnection.
+namespace AssociationFailure {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAssociationFailureCause), associationFailureCause));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStatus), status));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAssociationFailureCause))
+ {
+ err = DataModel::Decode(reader, associationFailureCause);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AssociationFailure.
+namespace ConnectionStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kConnectionStatus), connectionStatus));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kConnectionStatus))
+ {
+ err = DataModel::Decode(reader, connectionStatus);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ConnectionStatus.
+} // namespace Events
+
+} // namespace WiFiNetworkDiagnostics
+namespace EthernetNetworkDiagnostics {
+
+namespace Commands {
+namespace ResetCounts {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetCounts.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PHYRate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, PHYRate);
+ case Attributes::FullDuplex::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, fullDuplex);
+ case Attributes::PacketRxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, packetRxCount);
+ case Attributes::PacketTxCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, packetTxCount);
+ case Attributes::TxErrCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, txErrCount);
+ case Attributes::CollisionCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, collisionCount);
+ case Attributes::OverrunCount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, overrunCount);
+ case Attributes::CarrierDetect::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, carrierDetect);
+ case Attributes::TimeSinceReset::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timeSinceReset);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace EthernetNetworkDiagnostics
+namespace TimeSynchronization {
+namespace Structs {
+
+namespace DSTOffsetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOffset), offset);
+ encoder.Encode(to_underlying(Fields::kValidStarting), validStarting);
+ encoder.Encode(to_underlying(Fields::kValidUntil), validUntil);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOffset))
+ {
+ err = DataModel::Decode(reader, offset);
+ }
+ else if (__context_tag == to_underlying(Fields::kValidStarting))
+ {
+ err = DataModel::Decode(reader, validStarting);
+ }
+ else if (__context_tag == to_underlying(Fields::kValidUntil))
+ {
+ err = DataModel::Decode(reader, validUntil);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace DSTOffsetStruct
+
+namespace FabricScopedTrustedTimeSourceStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNodeID), nodeID);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNodeID))
+ {
+ err = DataModel::Decode(reader, nodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace FabricScopedTrustedTimeSourceStruct
+
+namespace TimeZoneStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOffset), offset);
+ encoder.Encode(to_underlying(Fields::kValidAt), validAt);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOffset))
+ {
+ err = DataModel::Decode(reader, offset);
+ }
+ else if (__context_tag == to_underlying(Fields::kValidAt))
+ {
+ err = DataModel::Decode(reader, validAt);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TimeZoneStruct
+
+namespace TrustedTimeSourceStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ encoder.Encode(to_underlying(Fields::kNodeID), nodeID);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kNodeID))
+ {
+ err = DataModel::Decode(reader, nodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TrustedTimeSourceStruct
+} // namespace Structs
+
+namespace Commands {
+namespace SetUTCTime {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUTCTime), UTCTime);
+ encoder.Encode(to_underlying(Fields::kGranularity), granularity);
+ encoder.Encode(to_underlying(Fields::kTimeSource), timeSource);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUTCTime))
+ {
+ err = DataModel::Decode(reader, UTCTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kGranularity))
+ {
+ err = DataModel::Decode(reader, granularity);
+ }
+ else if (__context_tag == to_underlying(Fields::kTimeSource))
+ {
+ err = DataModel::Decode(reader, timeSource);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetUTCTime.
+namespace SetTrustedTimeSource {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTrustedTimeSource), trustedTimeSource);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTrustedTimeSource))
+ {
+ err = DataModel::Decode(reader, trustedTimeSource);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTrustedTimeSource.
+namespace SetTimeZone {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTimeZone), timeZone);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTimeZone))
+ {
+ err = DataModel::Decode(reader, timeZone);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTimeZone.
+namespace SetTimeZoneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDSTOffsetRequired), DSTOffsetRequired);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDSTOffsetRequired))
+ {
+ err = DataModel::Decode(reader, DSTOffsetRequired);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTimeZoneResponse.
+namespace SetDSTOffset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDSTOffset), DSTOffset);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDSTOffset))
+ {
+ err = DataModel::Decode(reader, DSTOffset);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetDSTOffset.
+namespace SetDefaultNTP {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDefaultNTP), defaultNTP);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDefaultNTP))
+ {
+ err = DataModel::Decode(reader, defaultNTP);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetDefaultNTP.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::UTCTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, UTCTime);
+ case Attributes::Granularity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, granularity);
+ case Attributes::TimeSource::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timeSource);
+ case Attributes::TrustedTimeSource::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, trustedTimeSource);
+ case Attributes::DefaultNTP::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultNTP);
+ case Attributes::TimeZone::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timeZone);
+ case Attributes::DSTOffset::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, DSTOffset);
+ case Attributes::LocalTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localTime);
+ case Attributes::TimeZoneDatabase::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timeZoneDatabase);
+ case Attributes::NTPServerAvailable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, NTPServerAvailable);
+ case Attributes::TimeZoneListMaxSize::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timeZoneListMaxSize);
+ case Attributes::DSTOffsetListMaxSize::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, DSTOffsetListMaxSize);
+ case Attributes::SupportsDNSResolve::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportsDNSResolve);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace DSTTableEmpty {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace DSTTableEmpty.
+namespace DSTStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDSTOffsetActive), DSTOffsetActive));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDSTOffsetActive))
+ {
+ err = DataModel::Decode(reader, DSTOffsetActive);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DSTStatus.
+namespace TimeZoneStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOffset), offset));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kName), name));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOffset))
+ {
+ err = DataModel::Decode(reader, offset);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TimeZoneStatus.
+namespace TimeFailure {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TimeFailure.
+namespace MissingTrustedTimeSource {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace MissingTrustedTimeSource.
+} // namespace Events
+
+} // namespace TimeSynchronization
+namespace BridgedDeviceBasicInformation {
+namespace Structs {
+
+namespace ProductAppearanceStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kFinish), finish);
+ encoder.Encode(to_underlying(Fields::kPrimaryColor), primaryColor);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFinish))
+ {
+ err = DataModel::Decode(reader, finish);
+ }
+ else if (__context_tag == to_underlying(Fields::kPrimaryColor))
+ {
+ err = DataModel::Decode(reader, primaryColor);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProductAppearanceStruct
+} // namespace Structs
+
+namespace Commands {
+namespace KeepActive {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStayActiveDuration), stayActiveDuration);
+ encoder.Encode(to_underlying(Fields::kTimeoutMs), timeoutMs);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStayActiveDuration))
+ {
+ err = DataModel::Decode(reader, stayActiveDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kTimeoutMs))
+ {
+ err = DataModel::Decode(reader, timeoutMs);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace KeepActive.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::VendorName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorName);
+ case Attributes::VendorID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorID);
+ case Attributes::ProductName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productName);
+ case Attributes::ProductID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productID);
+ case Attributes::NodeLabel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nodeLabel);
+ case Attributes::HardwareVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hardwareVersion);
+ case Attributes::HardwareVersionString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hardwareVersionString);
+ case Attributes::SoftwareVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, softwareVersion);
+ case Attributes::SoftwareVersionString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, softwareVersionString);
+ case Attributes::ManufacturingDate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, manufacturingDate);
+ case Attributes::PartNumber::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, partNumber);
+ case Attributes::ProductURL::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productURL);
+ case Attributes::ProductLabel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productLabel);
+ case Attributes::SerialNumber::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, serialNumber);
+ case Attributes::Reachable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, reachable);
+ case Attributes::UniqueID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uniqueID);
+ case Attributes::ProductAppearance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productAppearance);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace StartUp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSoftwareVersion))
+ {
+ err = DataModel::Decode(reader, softwareVersion);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StartUp.
+namespace ShutDown {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ShutDown.
+namespace Leave {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Leave.
+namespace ReachableChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReachableNewValue), reachableNewValue));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReachableNewValue))
+ {
+ err = DataModel::Decode(reader, reachableNewValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReachableChanged.
+namespace ActiveChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPromisedActiveDuration), promisedActiveDuration));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPromisedActiveDuration))
+ {
+ err = DataModel::Decode(reader, promisedActiveDuration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ActiveChanged.
+} // namespace Events
+
+} // namespace BridgedDeviceBasicInformation
+namespace Switch {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::NumberOfPositions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfPositions);
+ case Attributes::CurrentPosition::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPosition);
+ case Attributes::MultiPressMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, multiPressMax);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace SwitchLatched {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewPosition))
+ {
+ err = DataModel::Decode(reader, newPosition);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SwitchLatched.
+namespace InitialPress {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewPosition))
+ {
+ err = DataModel::Decode(reader, newPosition);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace InitialPress.
+namespace LongPress {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewPosition))
+ {
+ err = DataModel::Decode(reader, newPosition);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LongPress.
+namespace ShortRelease {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPosition), previousPosition));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPreviousPosition))
+ {
+ err = DataModel::Decode(reader, previousPosition);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ShortRelease.
+namespace LongRelease {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPosition), previousPosition));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPreviousPosition))
+ {
+ err = DataModel::Decode(reader, previousPosition);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LongRelease.
+namespace MultiPressOngoing {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
+ ReturnErrorOnFailure(
+ DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentNumberOfPressesCounted), currentNumberOfPressesCounted));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewPosition))
+ {
+ err = DataModel::Decode(reader, newPosition);
+ }
+ else if (__context_tag == to_underlying(Fields::kCurrentNumberOfPressesCounted))
+ {
+ err = DataModel::Decode(reader, currentNumberOfPressesCounted);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MultiPressOngoing.
+namespace MultiPressComplete {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPosition), previousPosition));
+ ReturnErrorOnFailure(
+ DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalNumberOfPressesCounted), totalNumberOfPressesCounted));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPreviousPosition))
+ {
+ err = DataModel::Decode(reader, previousPosition);
+ }
+ else if (__context_tag == to_underlying(Fields::kTotalNumberOfPressesCounted))
+ {
+ err = DataModel::Decode(reader, totalNumberOfPressesCounted);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MultiPressComplete.
+} // namespace Events
+
+} // namespace Switch
+namespace AdministratorCommissioning {
+
+namespace Commands {
+namespace OpenCommissioningWindow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCommissioningTimeout), commissioningTimeout);
+ encoder.Encode(to_underlying(Fields::kPAKEPasscodeVerifier), PAKEPasscodeVerifier);
+ encoder.Encode(to_underlying(Fields::kDiscriminator), discriminator);
+ encoder.Encode(to_underlying(Fields::kIterations), iterations);
+ encoder.Encode(to_underlying(Fields::kSalt), salt);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCommissioningTimeout))
+ {
+ err = DataModel::Decode(reader, commissioningTimeout);
+ }
+ else if (__context_tag == to_underlying(Fields::kPAKEPasscodeVerifier))
+ {
+ err = DataModel::Decode(reader, PAKEPasscodeVerifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kDiscriminator))
+ {
+ err = DataModel::Decode(reader, discriminator);
+ }
+ else if (__context_tag == to_underlying(Fields::kIterations))
+ {
+ err = DataModel::Decode(reader, iterations);
+ }
+ else if (__context_tag == to_underlying(Fields::kSalt))
+ {
+ err = DataModel::Decode(reader, salt);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OpenCommissioningWindow.
+namespace OpenBasicCommissioningWindow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCommissioningTimeout), commissioningTimeout);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCommissioningTimeout))
+ {
+ err = DataModel::Decode(reader, commissioningTimeout);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OpenBasicCommissioningWindow.
+namespace RevokeCommissioning {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace RevokeCommissioning.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::WindowStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, windowStatus);
+ case Attributes::AdminFabricIndex::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, adminFabricIndex);
+ case Attributes::AdminVendorId::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, adminVendorId);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace AdministratorCommissioning
+namespace OperationalCredentials {
+namespace Structs {
+
+namespace FabricDescriptorStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ encoder.Encode(to_underlying(Fields::kRootPublicKey), rootPublicKey);
+ encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
+ encoder.Encode(to_underlying(Fields::kFabricID), fabricID);
+ encoder.Encode(to_underlying(Fields::kNodeID), nodeID);
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRootPublicKey))
+ {
+ err = DataModel::Decode(reader, rootPublicKey);
+ }
+ else if (__context_tag == to_underlying(Fields::kVendorID))
+ {
+ err = DataModel::Decode(reader, vendorID);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricID))
+ {
+ err = DataModel::Decode(reader, fabricID);
+ }
+ else if (__context_tag == to_underlying(Fields::kNodeID))
+ {
+ err = DataModel::Decode(reader, nodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace FabricDescriptorStruct
+
+namespace NOCStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kNoc), noc);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kIcac), icac);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNoc))
+ {
+ err = DataModel::Decode(reader, noc);
+ }
+ else if (__context_tag == to_underlying(Fields::kIcac))
+ {
+ err = DataModel::Decode(reader, icac);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NOCStruct
+} // namespace Structs
+
+namespace Commands {
+namespace AttestationRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAttestationNonce), attestationNonce);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAttestationNonce))
+ {
+ err = DataModel::Decode(reader, attestationNonce);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AttestationRequest.
+namespace AttestationResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAttestationElements), attestationElements);
+ encoder.Encode(to_underlying(Fields::kAttestationSignature), attestationSignature);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAttestationElements))
+ {
+ err = DataModel::Decode(reader, attestationElements);
+ }
+ else if (__context_tag == to_underlying(Fields::kAttestationSignature))
+ {
+ err = DataModel::Decode(reader, attestationSignature);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AttestationResponse.
+namespace CertificateChainRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCertificateType), certificateType);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCertificateType))
+ {
+ err = DataModel::Decode(reader, certificateType);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CertificateChainRequest.
+namespace CertificateChainResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCertificate), certificate);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCertificate))
+ {
+ err = DataModel::Decode(reader, certificate);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CertificateChainResponse.
+namespace CSRRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCSRNonce), CSRNonce);
+ encoder.Encode(to_underlying(Fields::kIsForUpdateNOC), isForUpdateNOC);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCSRNonce))
+ {
+ err = DataModel::Decode(reader, CSRNonce);
+ }
+ else if (__context_tag == to_underlying(Fields::kIsForUpdateNOC))
+ {
+ err = DataModel::Decode(reader, isForUpdateNOC);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CSRRequest.
+namespace CSRResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNOCSRElements), NOCSRElements);
+ encoder.Encode(to_underlying(Fields::kAttestationSignature), attestationSignature);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNOCSRElements))
+ {
+ err = DataModel::Decode(reader, NOCSRElements);
+ }
+ else if (__context_tag == to_underlying(Fields::kAttestationSignature))
+ {
+ err = DataModel::Decode(reader, attestationSignature);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CSRResponse.
+namespace AddNOC {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNOCValue), NOCValue);
+ encoder.Encode(to_underlying(Fields::kICACValue), ICACValue);
+ encoder.Encode(to_underlying(Fields::kIPKValue), IPKValue);
+ encoder.Encode(to_underlying(Fields::kCaseAdminSubject), caseAdminSubject);
+ encoder.Encode(to_underlying(Fields::kAdminVendorId), adminVendorId);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNOCValue))
+ {
+ err = DataModel::Decode(reader, NOCValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kICACValue))
+ {
+ err = DataModel::Decode(reader, ICACValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kIPKValue))
+ {
+ err = DataModel::Decode(reader, IPKValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kCaseAdminSubject))
+ {
+ err = DataModel::Decode(reader, caseAdminSubject);
+ }
+ else if (__context_tag == to_underlying(Fields::kAdminVendorId))
+ {
+ err = DataModel::Decode(reader, adminVendorId);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddNOC.
+namespace UpdateNOC {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNOCValue), NOCValue);
+ encoder.Encode(to_underlying(Fields::kICACValue), ICACValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNOCValue))
+ {
+ err = DataModel::Decode(reader, NOCValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kICACValue))
+ {
+ err = DataModel::Decode(reader, ICACValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UpdateNOC.
+namespace NOCResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatusCode), statusCode);
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ encoder.Encode(to_underlying(Fields::kDebugText), debugText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatusCode))
+ {
+ err = DataModel::Decode(reader, statusCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kDebugText))
+ {
+ err = DataModel::Decode(reader, debugText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NOCResponse.
+namespace UpdateFabricLabel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UpdateFabricLabel.
+namespace RemoveFabric {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveFabric.
+namespace AddTrustedRootCertificate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRootCACertificate), rootCACertificate);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRootCACertificate))
+ {
+ err = DataModel::Decode(reader, rootCACertificate);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddTrustedRootCertificate.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::NOCs::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, NOCs);
+ case Attributes::Fabrics::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, fabrics);
+ case Attributes::SupportedFabrics::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedFabrics);
+ case Attributes::CommissionedFabrics::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, commissionedFabrics);
+ case Attributes::TrustedRootCertificates::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, trustedRootCertificates);
+ case Attributes::CurrentFabricIndex::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentFabricIndex);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace OperationalCredentials
+namespace GroupKeyManagement {
+namespace Structs {
+
+namespace GroupInfoMapStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ encoder.Encode(to_underlying(Fields::kGroupId), groupId);
+ encoder.Encode(to_underlying(Fields::kEndpoints), endpoints);
+ encoder.Encode(to_underlying(Fields::kGroupName), groupName);
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupId))
+ {
+ err = DataModel::Decode(reader, groupId);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoints))
+ {
+ err = DataModel::Decode(reader, endpoints);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupName))
+ {
+ err = DataModel::Decode(reader, groupName);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace GroupInfoMapStruct
+
+namespace GroupKeyMapStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ encoder.Encode(to_underlying(Fields::kGroupId), groupId);
+ encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupId))
+ {
+ err = DataModel::Decode(reader, groupId);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupKeySetID))
+ {
+ err = DataModel::Decode(reader, groupKeySetID);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace GroupKeyMapStruct
+
+namespace GroupKeySetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
+ encoder.Encode(to_underlying(Fields::kGroupKeySecurityPolicy), groupKeySecurityPolicy);
+ encoder.Encode(to_underlying(Fields::kEpochKey0), epochKey0);
+ encoder.Encode(to_underlying(Fields::kEpochStartTime0), epochStartTime0);
+ encoder.Encode(to_underlying(Fields::kEpochKey1), epochKey1);
+ encoder.Encode(to_underlying(Fields::kEpochStartTime1), epochStartTime1);
+ encoder.Encode(to_underlying(Fields::kEpochKey2), epochKey2);
+ encoder.Encode(to_underlying(Fields::kEpochStartTime2), epochStartTime2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupKeySetID))
+ {
+ err = DataModel::Decode(reader, groupKeySetID);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupKeySecurityPolicy))
+ {
+ err = DataModel::Decode(reader, groupKeySecurityPolicy);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpochKey0))
+ {
+ err = DataModel::Decode(reader, epochKey0);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpochStartTime0))
+ {
+ err = DataModel::Decode(reader, epochStartTime0);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpochKey1))
+ {
+ err = DataModel::Decode(reader, epochKey1);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpochStartTime1))
+ {
+ err = DataModel::Decode(reader, epochStartTime1);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpochKey2))
+ {
+ err = DataModel::Decode(reader, epochKey2);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpochStartTime2))
+ {
+ err = DataModel::Decode(reader, epochStartTime2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace GroupKeySetStruct
+} // namespace Structs
+
+namespace Commands {
+namespace KeySetWrite {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupKeySet), groupKeySet);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupKeySet))
+ {
+ err = DataModel::Decode(reader, groupKeySet);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace KeySetWrite.
+namespace KeySetRead {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupKeySetID))
+ {
+ err = DataModel::Decode(reader, groupKeySetID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace KeySetRead.
+namespace KeySetReadResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupKeySet), groupKeySet);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupKeySet))
+ {
+ err = DataModel::Decode(reader, groupKeySet);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace KeySetReadResponse.
+namespace KeySetRemove {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupKeySetID))
+ {
+ err = DataModel::Decode(reader, groupKeySetID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace KeySetRemove.
+namespace KeySetReadAllIndices {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace KeySetReadAllIndices.
+namespace KeySetReadAllIndicesResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupKeySetIDs), groupKeySetIDs);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupKeySetIDs))
+ {
+ err = DataModel::Decode(reader, groupKeySetIDs);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace KeySetReadAllIndicesResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GroupKeyMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, groupKeyMap);
+ case Attributes::GroupTable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, groupTable);
+ case Attributes::MaxGroupsPerFabric::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxGroupsPerFabric);
+ case Attributes::MaxGroupKeysPerFabric::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxGroupKeysPerFabric);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace GroupKeyManagement
+namespace FixedLabel {
+namespace Structs {} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::LabelList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, labelList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace FixedLabel
+namespace UserLabel {
+namespace Structs {} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::LabelList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, labelList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace UserLabel
+namespace ProxyConfiguration {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ProxyConfiguration
+namespace ProxyDiscovery {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ProxyDiscovery
+namespace ProxyValid {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ProxyValid
+namespace BooleanState {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::StateValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, stateValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace StateChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStateValue), stateValue));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStateValue))
+ {
+ err = DataModel::Decode(reader, stateValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StateChange.
+} // namespace Events
+
+} // namespace BooleanState
+namespace IcdManagement {
+namespace Structs {
+
+namespace MonitoringRegistrationStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kCheckInNodeID), checkInNodeID);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kMonitoredSubject), monitoredSubject);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kClientType), clientType);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCheckInNodeID))
+ {
+ err = DataModel::Decode(reader, checkInNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kMonitoredSubject))
+ {
+ err = DataModel::Decode(reader, monitoredSubject);
+ }
+ else if (__context_tag == to_underlying(Fields::kClientType))
+ {
+ err = DataModel::Decode(reader, clientType);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MonitoringRegistrationStruct
+} // namespace Structs
+
+namespace Commands {
+namespace RegisterClient {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCheckInNodeID), checkInNodeID);
+ encoder.Encode(to_underlying(Fields::kMonitoredSubject), monitoredSubject);
+ encoder.Encode(to_underlying(Fields::kKey), key);
+ encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
+ encoder.Encode(to_underlying(Fields::kClientType), clientType);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCheckInNodeID))
+ {
+ err = DataModel::Decode(reader, checkInNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kMonitoredSubject))
+ {
+ err = DataModel::Decode(reader, monitoredSubject);
+ }
+ else if (__context_tag == to_underlying(Fields::kKey))
+ {
+ err = DataModel::Decode(reader, key);
+ }
+ else if (__context_tag == to_underlying(Fields::kVerificationKey))
+ {
+ err = DataModel::Decode(reader, verificationKey);
+ }
+ else if (__context_tag == to_underlying(Fields::kClientType))
+ {
+ err = DataModel::Decode(reader, clientType);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RegisterClient.
+namespace RegisterClientResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kICDCounter), ICDCounter);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kICDCounter))
+ {
+ err = DataModel::Decode(reader, ICDCounter);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RegisterClientResponse.
+namespace UnregisterClient {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCheckInNodeID), checkInNodeID);
+ encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCheckInNodeID))
+ {
+ err = DataModel::Decode(reader, checkInNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kVerificationKey))
+ {
+ err = DataModel::Decode(reader, verificationKey);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UnregisterClient.
+namespace StayActiveRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStayActiveDuration), stayActiveDuration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStayActiveDuration))
+ {
+ err = DataModel::Decode(reader, stayActiveDuration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StayActiveRequest.
+namespace StayActiveResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPromisedActiveDuration), promisedActiveDuration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPromisedActiveDuration))
+ {
+ err = DataModel::Decode(reader, promisedActiveDuration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StayActiveResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::IdleModeDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, idleModeDuration);
+ case Attributes::ActiveModeDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeModeDuration);
+ case Attributes::ActiveModeThreshold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeModeThreshold);
+ case Attributes::RegisteredClients::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, registeredClients);
+ case Attributes::ICDCounter::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ICDCounter);
+ case Attributes::ClientsSupportedPerFabric::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clientsSupportedPerFabric);
+ case Attributes::UserActiveModeTriggerHint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, userActiveModeTriggerHint);
+ case Attributes::UserActiveModeTriggerInstruction::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, userActiveModeTriggerInstruction);
+ case Attributes::OperatingMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operatingMode);
+ case Attributes::MaximumCheckInBackOff::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maximumCheckInBackOff);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace IcdManagement
+namespace Timer {
+
+namespace Commands {
+namespace SetTimer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewTime), newTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewTime))
+ {
+ err = DataModel::Decode(reader, newTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTimer.
+namespace ResetTimer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetTimer.
+namespace AddTime {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAdditionalTime), additionalTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAdditionalTime))
+ {
+ err = DataModel::Decode(reader, additionalTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddTime.
+namespace ReduceTime {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTimeReduction), timeReduction);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTimeReduction))
+ {
+ err = DataModel::Decode(reader, timeReduction);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReduceTime.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SetTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, setTime);
+ case Attributes::TimeRemaining::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timeRemaining);
+ case Attributes::TimerState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timerState);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Timer
+namespace OvenCavityOperationalState {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace Pause {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Pause.
+namespace Stop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Stop.
+namespace Start {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Start.
+namespace Resume {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Resume.
+namespace OperationalCommandResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCommandResponseState), commandResponseState);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCommandResponseState))
+ {
+ err = DataModel::Decode(reader, commandResponseState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalCommandResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PhaseList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, phaseList);
+ case Attributes::CurrentPhase::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPhase);
+ case Attributes::CountdownTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, countdownTime);
+ case Attributes::OperationalStateList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalStateList);
+ case Attributes::OperationalState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalState);
+ case Attributes::OperationalError::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalError);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace OperationalError {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kErrorState), errorState));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorState))
+ {
+ err = DataModel::Decode(reader, errorState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalError.
+namespace OperationCompletion {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCompletionErrorCode), completionErrorCode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalOperationalTime), totalOperationalTime));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPausedTime), pausedTime));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCompletionErrorCode))
+ {
+ err = DataModel::Decode(reader, completionErrorCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
+ {
+ err = DataModel::Decode(reader, totalOperationalTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kPausedTime))
+ {
+ err = DataModel::Decode(reader, pausedTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationCompletion.
+} // namespace Events
+
+} // namespace OvenCavityOperationalState
+namespace OvenMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::StartUpMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpMode);
+ case Attributes::OnMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace OvenMode
+namespace LaundryDryerControls {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedDrynessLevels::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedDrynessLevels);
+ case Attributes::SelectedDrynessLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, selectedDrynessLevel);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace LaundryDryerControls
+namespace ModeSelect {
+namespace Structs {
+
+namespace SemanticTagStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMfgCode), mfgCode);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMfgCode))
+ {
+ err = DataModel::Decode(reader, mfgCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SemanticTagStruct
+
+namespace ModeOptionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ encoder.Encode(to_underlying(Fields::kMode), mode);
+ encoder.Encode(to_underlying(Fields::kSemanticTags), semanticTags);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else if (__context_tag == to_underlying(Fields::kMode))
+ {
+ err = DataModel::Decode(reader, mode);
+ }
+ else if (__context_tag == to_underlying(Fields::kSemanticTags))
+ {
+ err = DataModel::Decode(reader, semanticTags);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ModeOptionStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Description::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, description);
+ case Attributes::StandardNamespace::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, standardNamespace);
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::StartUpMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpMode);
+ case Attributes::OnMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ModeSelect
+namespace LaundryWasherMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::StartUpMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpMode);
+ case Attributes::OnMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace LaundryWasherMode
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::StartUpMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpMode);
+ case Attributes::OnMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+namespace LaundryWasherControls {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SpinSpeeds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, spinSpeeds);
+ case Attributes::SpinSpeedCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, spinSpeedCurrent);
+ case Attributes::NumberOfRinses::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfRinses);
+ case Attributes::SupportedRinses::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedRinses);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace LaundryWasherControls
+namespace RvcRunMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace RvcRunMode
+namespace RvcCleanMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace RvcCleanMode
+namespace TemperatureControl {
+
+namespace Commands {
+namespace SetTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTargetTemperature), targetTemperature);
+ encoder.Encode(to_underlying(Fields::kTargetTemperatureLevel), targetTemperatureLevel);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTargetTemperature))
+ {
+ err = DataModel::Decode(reader, targetTemperature);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargetTemperatureLevel))
+ {
+ err = DataModel::Decode(reader, targetTemperatureLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTemperature.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::TemperatureSetpoint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, temperatureSetpoint);
+ case Attributes::MinTemperature::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minTemperature);
+ case Attributes::MaxTemperature::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxTemperature);
+ case Attributes::Step::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, step);
+ case Attributes::SelectedTemperatureLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, selectedTemperatureLevel);
+ case Attributes::SupportedTemperatureLevels::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedTemperatureLevels);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Mask::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, mask);
+ case Attributes::State::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, state);
+ case Attributes::Supported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supported);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace Notify {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActive), active));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInactive), inactive));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMask), mask));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActive))
+ {
+ err = DataModel::Decode(reader, active);
+ }
+ else if (__context_tag == to_underlying(Fields::kInactive))
+ {
+ err = DataModel::Decode(reader, inactive);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else if (__context_tag == to_underlying(Fields::kMask))
+ {
+ err = DataModel::Decode(reader, mask);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Notify.
+} // namespace Events
+
+} // namespace RefrigeratorAlarm
+namespace DishwasherMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::StartUpMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpMode);
+ case Attributes::OnMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace DishwasherMode
+namespace AirQuality {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::AirQuality::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, airQuality);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace AirQuality
+namespace SmokeCoAlarm {
+
+namespace Commands {
+namespace SelfTestRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SelfTestRequest.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::ExpressedState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, expressedState);
+ case Attributes::SmokeState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, smokeState);
+ case Attributes::COState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, COState);
+ case Attributes::BatteryAlert::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batteryAlert);
+ case Attributes::DeviceMuted::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, deviceMuted);
+ case Attributes::TestInProgress::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, testInProgress);
+ case Attributes::HardwareFaultAlert::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hardwareFaultAlert);
+ case Attributes::EndOfServiceAlert::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, endOfServiceAlert);
+ case Attributes::InterconnectSmokeAlarm::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, interconnectSmokeAlarm);
+ case Attributes::InterconnectCOAlarm::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, interconnectCOAlarm);
+ case Attributes::ContaminationState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, contaminationState);
+ case Attributes::SmokeSensitivityLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, smokeSensitivityLevel);
+ case Attributes::ExpiryDate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, expiryDate);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace SmokeAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
+ {
+ err = DataModel::Decode(reader, alarmSeverityLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SmokeAlarm.
+namespace COAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
+ {
+ err = DataModel::Decode(reader, alarmSeverityLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace COAlarm.
+namespace LowBattery {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
+ {
+ err = DataModel::Decode(reader, alarmSeverityLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LowBattery.
+namespace HardwareFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace HardwareFault.
+namespace EndOfService {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace EndOfService.
+namespace SelfTestComplete {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SelfTestComplete.
+namespace AlarmMuted {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace AlarmMuted.
+namespace MuteEnded {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace MuteEnded.
+namespace InterconnectSmokeAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
+ {
+ err = DataModel::Decode(reader, alarmSeverityLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace InterconnectSmokeAlarm.
+namespace InterconnectCOAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
+ {
+ err = DataModel::Decode(reader, alarmSeverityLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace InterconnectCOAlarm.
+namespace AllClear {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace AllClear.
+} // namespace Events
+
+} // namespace SmokeCoAlarm
+namespace DishwasherAlarm {
+
+namespace Commands {
+namespace Reset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAlarms), alarms);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarms))
+ {
+ err = DataModel::Decode(reader, alarms);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Reset.
+namespace ModifyEnabledAlarms {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMask), mask);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMask))
+ {
+ err = DataModel::Decode(reader, mask);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ModifyEnabledAlarms.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Mask::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, mask);
+ case Attributes::Latch::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, latch);
+ case Attributes::State::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, state);
+ case Attributes::Supported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supported);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace Notify {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActive), active));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInactive), inactive));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMask), mask));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActive))
+ {
+ err = DataModel::Decode(reader, active);
+ }
+ else if (__context_tag == to_underlying(Fields::kInactive))
+ {
+ err = DataModel::Decode(reader, inactive);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else if (__context_tag == to_underlying(Fields::kMask))
+ {
+ err = DataModel::Decode(reader, mask);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Notify.
+} // namespace Events
+
+} // namespace DishwasherAlarm
+namespace MicrowaveOvenMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace MicrowaveOvenMode
+namespace MicrowaveOvenControl {
+
+namespace Commands {
+namespace SetCookingParameters {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCookMode), cookMode);
+ encoder.Encode(to_underlying(Fields::kCookTime), cookTime);
+ encoder.Encode(to_underlying(Fields::kPowerSetting), powerSetting);
+ encoder.Encode(to_underlying(Fields::kWattSettingIndex), wattSettingIndex);
+ encoder.Encode(to_underlying(Fields::kStartAfterSetting), startAfterSetting);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCookMode))
+ {
+ err = DataModel::Decode(reader, cookMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kCookTime))
+ {
+ err = DataModel::Decode(reader, cookTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kPowerSetting))
+ {
+ err = DataModel::Decode(reader, powerSetting);
+ }
+ else if (__context_tag == to_underlying(Fields::kWattSettingIndex))
+ {
+ err = DataModel::Decode(reader, wattSettingIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartAfterSetting))
+ {
+ err = DataModel::Decode(reader, startAfterSetting);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetCookingParameters.
+namespace AddMoreTime {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTimeToAdd), timeToAdd);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTimeToAdd))
+ {
+ err = DataModel::Decode(reader, timeToAdd);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddMoreTime.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CookTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, cookTime);
+ case Attributes::MaxCookTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxCookTime);
+ case Attributes::PowerSetting::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, powerSetting);
+ case Attributes::MinPower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minPower);
+ case Attributes::MaxPower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxPower);
+ case Attributes::PowerStep::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, powerStep);
+ case Attributes::SupportedWatts::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedWatts);
+ case Attributes::SelectedWattIndex::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, selectedWattIndex);
+ case Attributes::WattRating::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wattRating);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace MicrowaveOvenControl
+namespace OperationalState {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace Pause {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Pause.
+namespace Stop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Stop.
+namespace Start {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Start.
+namespace Resume {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Resume.
+namespace OperationalCommandResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCommandResponseState), commandResponseState);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCommandResponseState))
+ {
+ err = DataModel::Decode(reader, commandResponseState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalCommandResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PhaseList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, phaseList);
+ case Attributes::CurrentPhase::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPhase);
+ case Attributes::CountdownTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, countdownTime);
+ case Attributes::OperationalStateList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalStateList);
+ case Attributes::OperationalState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalState);
+ case Attributes::OperationalError::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalError);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace OperationalError {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kErrorState), errorState));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorState))
+ {
+ err = DataModel::Decode(reader, errorState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalError.
+namespace OperationCompletion {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCompletionErrorCode), completionErrorCode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalOperationalTime), totalOperationalTime));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPausedTime), pausedTime));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCompletionErrorCode))
+ {
+ err = DataModel::Decode(reader, completionErrorCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
+ {
+ err = DataModel::Decode(reader, totalOperationalTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kPausedTime))
+ {
+ err = DataModel::Decode(reader, pausedTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationCompletion.
+} // namespace Events
+
+} // namespace OperationalState
+namespace RvcOperationalState {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace Pause {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Pause.
+namespace Resume {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Resume.
+namespace OperationalCommandResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCommandResponseState), commandResponseState);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCommandResponseState))
+ {
+ err = DataModel::Decode(reader, commandResponseState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalCommandResponse.
+namespace GoHome {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace GoHome.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PhaseList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, phaseList);
+ case Attributes::CurrentPhase::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPhase);
+ case Attributes::CountdownTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, countdownTime);
+ case Attributes::OperationalStateList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalStateList);
+ case Attributes::OperationalState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalState);
+ case Attributes::OperationalError::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalError);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace OperationalError {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kErrorState), errorState));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kErrorState))
+ {
+ err = DataModel::Decode(reader, errorState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalError.
+namespace OperationCompletion {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCompletionErrorCode), completionErrorCode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalOperationalTime), totalOperationalTime));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPausedTime), pausedTime));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCompletionErrorCode))
+ {
+ err = DataModel::Decode(reader, completionErrorCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
+ {
+ err = DataModel::Decode(reader, totalOperationalTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kPausedTime))
+ {
+ err = DataModel::Decode(reader, pausedTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationCompletion.
+} // namespace Events
+
+} // namespace RvcOperationalState
+namespace ScenesManagement {
+namespace Structs {
+
+namespace AttributeValuePairStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAttributeID), attributeID);
+ encoder.Encode(to_underlying(Fields::kValueUnsigned8), valueUnsigned8);
+ encoder.Encode(to_underlying(Fields::kValueSigned8), valueSigned8);
+ encoder.Encode(to_underlying(Fields::kValueUnsigned16), valueUnsigned16);
+ encoder.Encode(to_underlying(Fields::kValueSigned16), valueSigned16);
+ encoder.Encode(to_underlying(Fields::kValueUnsigned32), valueUnsigned32);
+ encoder.Encode(to_underlying(Fields::kValueSigned32), valueSigned32);
+ encoder.Encode(to_underlying(Fields::kValueUnsigned64), valueUnsigned64);
+ encoder.Encode(to_underlying(Fields::kValueSigned64), valueSigned64);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAttributeID))
+ {
+ err = DataModel::Decode(reader, attributeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueUnsigned8))
+ {
+ err = DataModel::Decode(reader, valueUnsigned8);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueSigned8))
+ {
+ err = DataModel::Decode(reader, valueSigned8);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueUnsigned16))
+ {
+ err = DataModel::Decode(reader, valueUnsigned16);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueSigned16))
+ {
+ err = DataModel::Decode(reader, valueSigned16);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueUnsigned32))
+ {
+ err = DataModel::Decode(reader, valueUnsigned32);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueSigned32))
+ {
+ err = DataModel::Decode(reader, valueSigned32);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueUnsigned64))
+ {
+ err = DataModel::Decode(reader, valueUnsigned64);
+ }
+ else if (__context_tag == to_underlying(Fields::kValueSigned64))
+ {
+ err = DataModel::Decode(reader, valueSigned64);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AttributeValuePairStruct
+
+namespace ExtensionFieldSet {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kClusterID), clusterID);
+ encoder.Encode(to_underlying(Fields::kAttributeValueList), attributeValueList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kClusterID))
+ {
+ err = DataModel::Decode(reader, clusterID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAttributeValueList))
+ {
+ err = DataModel::Decode(reader, attributeValueList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ExtensionFieldSet
+
+namespace SceneInfoStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ encoder.Encode(to_underlying(Fields::kSceneCount), sceneCount);
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kCurrentScene), currentScene);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kCurrentGroup), currentGroup);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kSceneValid), sceneValid);
+ }
+ encoder.Encode(to_underlying(Fields::kRemainingCapacity), remainingCapacity);
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSceneCount))
+ {
+ err = DataModel::Decode(reader, sceneCount);
+ }
+ else if (__context_tag == to_underlying(Fields::kCurrentScene))
+ {
+ err = DataModel::Decode(reader, currentScene);
+ }
+ else if (__context_tag == to_underlying(Fields::kCurrentGroup))
+ {
+ err = DataModel::Decode(reader, currentGroup);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneValid))
+ {
+ err = DataModel::Decode(reader, sceneValid);
+ }
+ else if (__context_tag == to_underlying(Fields::kRemainingCapacity))
+ {
+ err = DataModel::Decode(reader, remainingCapacity);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SceneInfoStruct
+} // namespace Structs
+
+namespace Commands {
+namespace AddScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kSceneName), sceneName);
+ encoder.Encode(to_underlying(Fields::kExtensionFieldSets), extensionFieldSets);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneName))
+ {
+ err = DataModel::Decode(reader, sceneName);
+ }
+ else if (__context_tag == to_underlying(Fields::kExtensionFieldSets))
+ {
+ err = DataModel::Decode(reader, extensionFieldSets);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddScene.
+namespace AddSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddSceneResponse.
+namespace ViewScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ViewScene.
+namespace ViewSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kSceneName), sceneName);
+ encoder.Encode(to_underlying(Fields::kExtensionFieldSets), extensionFieldSets);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneName))
+ {
+ err = DataModel::Decode(reader, sceneName);
+ }
+ else if (__context_tag == to_underlying(Fields::kExtensionFieldSets))
+ {
+ err = DataModel::Decode(reader, extensionFieldSets);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ViewSceneResponse.
+namespace RemoveScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveScene.
+namespace RemoveSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveSceneResponse.
+namespace RemoveAllScenes {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveAllScenes.
+namespace RemoveAllScenesResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveAllScenesResponse.
+namespace StoreScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StoreScene.
+namespace StoreSceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StoreSceneResponse.
+namespace RecallScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneID))
+ {
+ err = DataModel::Decode(reader, sceneID);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RecallScene.
+namespace GetSceneMembership {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetSceneMembership.
+namespace GetSceneMembershipResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kCapacity), capacity);
+ encoder.Encode(to_underlying(Fields::kGroupID), groupID);
+ encoder.Encode(to_underlying(Fields::kSceneList), sceneList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kCapacity))
+ {
+ err = DataModel::Decode(reader, capacity);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupID))
+ {
+ err = DataModel::Decode(reader, groupID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneList))
+ {
+ err = DataModel::Decode(reader, sceneList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetSceneMembershipResponse.
+namespace CopyScene {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMode), mode);
+ encoder.Encode(to_underlying(Fields::kGroupIdentifierFrom), groupIdentifierFrom);
+ encoder.Encode(to_underlying(Fields::kSceneIdentifierFrom), sceneIdentifierFrom);
+ encoder.Encode(to_underlying(Fields::kGroupIdentifierTo), groupIdentifierTo);
+ encoder.Encode(to_underlying(Fields::kSceneIdentifierTo), sceneIdentifierTo);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMode))
+ {
+ err = DataModel::Decode(reader, mode);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupIdentifierFrom))
+ {
+ err = DataModel::Decode(reader, groupIdentifierFrom);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneIdentifierFrom))
+ {
+ err = DataModel::Decode(reader, sceneIdentifierFrom);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupIdentifierTo))
+ {
+ err = DataModel::Decode(reader, groupIdentifierTo);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneIdentifierTo))
+ {
+ err = DataModel::Decode(reader, sceneIdentifierTo);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CopyScene.
+namespace CopySceneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kGroupIdentifierFrom), groupIdentifierFrom);
+ encoder.Encode(to_underlying(Fields::kSceneIdentifierFrom), sceneIdentifierFrom);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupIdentifierFrom))
+ {
+ err = DataModel::Decode(reader, groupIdentifierFrom);
+ }
+ else if (__context_tag == to_underlying(Fields::kSceneIdentifierFrom))
+ {
+ err = DataModel::Decode(reader, sceneIdentifierFrom);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CopySceneResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::LastConfiguredBy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lastConfiguredBy);
+ case Attributes::SceneTableSize::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sceneTableSize);
+ case Attributes::FabricSceneInfo::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, fabricSceneInfo);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ScenesManagement
+namespace HepaFilterMonitoring {
+namespace Structs {
+
+namespace ReplacementProductStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProductIdentifierType), productIdentifierType);
+ encoder.Encode(to_underlying(Fields::kProductIdentifierValue), productIdentifierValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProductIdentifierType))
+ {
+ err = DataModel::Decode(reader, productIdentifierType);
+ }
+ else if (__context_tag == to_underlying(Fields::kProductIdentifierValue))
+ {
+ err = DataModel::Decode(reader, productIdentifierValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ReplacementProductStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ResetCondition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetCondition.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Condition::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, condition);
+ case Attributes::DegradationDirection::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, degradationDirection);
+ case Attributes::ChangeIndication::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, changeIndication);
+ case Attributes::InPlaceIndicator::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, inPlaceIndicator);
+ case Attributes::LastChangedTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lastChangedTime);
+ case Attributes::ReplacementProductList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, replacementProductList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace HepaFilterMonitoring
+namespace ActivatedCarbonFilterMonitoring {
+namespace Structs {
+
+namespace ReplacementProductStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProductIdentifierType), productIdentifierType);
+ encoder.Encode(to_underlying(Fields::kProductIdentifierValue), productIdentifierValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProductIdentifierType))
+ {
+ err = DataModel::Decode(reader, productIdentifierType);
+ }
+ else if (__context_tag == to_underlying(Fields::kProductIdentifierValue))
+ {
+ err = DataModel::Decode(reader, productIdentifierValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ReplacementProductStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ResetCondition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetCondition.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Condition::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, condition);
+ case Attributes::DegradationDirection::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, degradationDirection);
+ case Attributes::ChangeIndication::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, changeIndication);
+ case Attributes::InPlaceIndicator::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, inPlaceIndicator);
+ case Attributes::LastChangedTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lastChangedTime);
+ case Attributes::ReplacementProductList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, replacementProductList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ActivatedCarbonFilterMonitoring
+namespace BooleanStateConfiguration {
+
+namespace Commands {
+namespace SuppressAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAlarmsToSuppress), alarmsToSuppress);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmsToSuppress))
+ {
+ err = DataModel::Decode(reader, alarmsToSuppress);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SuppressAlarm.
+namespace EnableDisableAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAlarmsToEnableDisable), alarmsToEnableDisable);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmsToEnableDisable))
+ {
+ err = DataModel::Decode(reader, alarmsToEnableDisable);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnableDisableAlarm.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CurrentSensitivityLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentSensitivityLevel);
+ case Attributes::SupportedSensitivityLevels::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedSensitivityLevels);
+ case Attributes::DefaultSensitivityLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultSensitivityLevel);
+ case Attributes::AlarmsActive::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, alarmsActive);
+ case Attributes::AlarmsSuppressed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, alarmsSuppressed);
+ case Attributes::AlarmsEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, alarmsEnabled);
+ case Attributes::AlarmsSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, alarmsSupported);
+ case Attributes::SensorFault::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sensorFault);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace AlarmsStateChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmsActive), alarmsActive));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmsSuppressed), alarmsSuppressed));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmsActive))
+ {
+ err = DataModel::Decode(reader, alarmsActive);
+ }
+ else if (__context_tag == to_underlying(Fields::kAlarmsSuppressed))
+ {
+ err = DataModel::Decode(reader, alarmsSuppressed);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AlarmsStateChanged.
+namespace SensorFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSensorFault), sensorFault));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSensorFault))
+ {
+ err = DataModel::Decode(reader, sensorFault);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SensorFault.
+} // namespace Events
+
+} // namespace BooleanStateConfiguration
+namespace ValveConfigurationAndControl {
+
+namespace Commands {
+namespace Open {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOpenDuration), openDuration);
+ encoder.Encode(to_underlying(Fields::kTargetLevel), targetLevel);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOpenDuration))
+ {
+ err = DataModel::Decode(reader, openDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargetLevel))
+ {
+ err = DataModel::Decode(reader, targetLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Open.
+namespace Close {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Close.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::OpenDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, openDuration);
+ case Attributes::DefaultOpenDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultOpenDuration);
+ case Attributes::AutoCloseTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, autoCloseTime);
+ case Attributes::RemainingDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, remainingDuration);
+ case Attributes::CurrentState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentState);
+ case Attributes::TargetState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, targetState);
+ case Attributes::CurrentLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentLevel);
+ case Attributes::TargetLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, targetLevel);
+ case Attributes::DefaultOpenLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultOpenLevel);
+ case Attributes::ValveFault::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, valveFault);
+ case Attributes::LevelStep::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelStep);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace ValveStateChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveState), valveState));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveLevel), valveLevel));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kValveState))
+ {
+ err = DataModel::Decode(reader, valveState);
+ }
+ else if (__context_tag == to_underlying(Fields::kValveLevel))
+ {
+ err = DataModel::Decode(reader, valveLevel);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ValveStateChanged.
+namespace ValveFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveFault), valveFault));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kValveFault))
+ {
+ err = DataModel::Decode(reader, valveFault);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ValveFault.
+} // namespace Events
+
+} // namespace ValveConfigurationAndControl
+namespace ElectricalPowerMeasurement {
+namespace Structs {
+
+namespace HarmonicMeasurementStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOrder), order);
+ encoder.Encode(to_underlying(Fields::kMeasurement), measurement);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOrder))
+ {
+ err = DataModel::Decode(reader, order);
+ }
+ else if (__context_tag == to_underlying(Fields::kMeasurement))
+ {
+ err = DataModel::Decode(reader, measurement);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace HarmonicMeasurementStruct
+
+namespace MeasurementRangeStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMeasurementType), measurementType);
+ encoder.Encode(to_underlying(Fields::kMin), min);
+ encoder.Encode(to_underlying(Fields::kMax), max);
+ encoder.Encode(to_underlying(Fields::kStartTimestamp), startTimestamp);
+ encoder.Encode(to_underlying(Fields::kEndTimestamp), endTimestamp);
+ encoder.Encode(to_underlying(Fields::kMinTimestamp), minTimestamp);
+ encoder.Encode(to_underlying(Fields::kMaxTimestamp), maxTimestamp);
+ encoder.Encode(to_underlying(Fields::kStartSystime), startSystime);
+ encoder.Encode(to_underlying(Fields::kEndSystime), endSystime);
+ encoder.Encode(to_underlying(Fields::kMinSystime), minSystime);
+ encoder.Encode(to_underlying(Fields::kMaxSystime), maxSystime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMeasurementType))
+ {
+ err = DataModel::Decode(reader, measurementType);
+ }
+ else if (__context_tag == to_underlying(Fields::kMin))
+ {
+ err = DataModel::Decode(reader, min);
+ }
+ else if (__context_tag == to_underlying(Fields::kMax))
+ {
+ err = DataModel::Decode(reader, max);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTimestamp))
+ {
+ err = DataModel::Decode(reader, startTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndTimestamp))
+ {
+ err = DataModel::Decode(reader, endTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinTimestamp))
+ {
+ err = DataModel::Decode(reader, minTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxTimestamp))
+ {
+ err = DataModel::Decode(reader, maxTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartSystime))
+ {
+ err = DataModel::Decode(reader, startSystime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndSystime))
+ {
+ err = DataModel::Decode(reader, endSystime);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinSystime))
+ {
+ err = DataModel::Decode(reader, minSystime);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxSystime))
+ {
+ err = DataModel::Decode(reader, maxSystime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MeasurementRangeStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PowerMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, powerMode);
+ case Attributes::NumberOfMeasurementTypes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfMeasurementTypes);
+ case Attributes::Accuracy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, accuracy);
+ case Attributes::Ranges::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ranges);
+ case Attributes::Voltage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, voltage);
+ case Attributes::ActiveCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeCurrent);
+ case Attributes::ReactiveCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, reactiveCurrent);
+ case Attributes::ApparentCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, apparentCurrent);
+ case Attributes::ActivePower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activePower);
+ case Attributes::ReactivePower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, reactivePower);
+ case Attributes::ApparentPower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, apparentPower);
+ case Attributes::RMSVoltage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, RMSVoltage);
+ case Attributes::RMSCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, RMSCurrent);
+ case Attributes::RMSPower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, RMSPower);
+ case Attributes::Frequency::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, frequency);
+ case Attributes::HarmonicCurrents::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, harmonicCurrents);
+ case Attributes::HarmonicPhases::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, harmonicPhases);
+ case Attributes::PowerFactor::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, powerFactor);
+ case Attributes::NeutralCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, neutralCurrent);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace MeasurementPeriodRanges {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kRanges), ranges));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRanges))
+ {
+ err = DataModel::Decode(reader, ranges);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MeasurementPeriodRanges.
+} // namespace Events
+
+} // namespace ElectricalPowerMeasurement
+namespace ElectricalEnergyMeasurement {
+namespace Structs {
+
+namespace CumulativeEnergyResetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kImportedResetTimestamp), importedResetTimestamp);
+ encoder.Encode(to_underlying(Fields::kExportedResetTimestamp), exportedResetTimestamp);
+ encoder.Encode(to_underlying(Fields::kImportedResetSystime), importedResetSystime);
+ encoder.Encode(to_underlying(Fields::kExportedResetSystime), exportedResetSystime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kImportedResetTimestamp))
+ {
+ err = DataModel::Decode(reader, importedResetTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kExportedResetTimestamp))
+ {
+ err = DataModel::Decode(reader, exportedResetTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kImportedResetSystime))
+ {
+ err = DataModel::Decode(reader, importedResetSystime);
+ }
+ else if (__context_tag == to_underlying(Fields::kExportedResetSystime))
+ {
+ err = DataModel::Decode(reader, exportedResetSystime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace CumulativeEnergyResetStruct
+
+namespace EnergyMeasurementStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEnergy), energy);
+ encoder.Encode(to_underlying(Fields::kStartTimestamp), startTimestamp);
+ encoder.Encode(to_underlying(Fields::kEndTimestamp), endTimestamp);
+ encoder.Encode(to_underlying(Fields::kStartSystime), startSystime);
+ encoder.Encode(to_underlying(Fields::kEndSystime), endSystime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnergy))
+ {
+ err = DataModel::Decode(reader, energy);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTimestamp))
+ {
+ err = DataModel::Decode(reader, startTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndTimestamp))
+ {
+ err = DataModel::Decode(reader, endTimestamp);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartSystime))
+ {
+ err = DataModel::Decode(reader, startSystime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndSystime))
+ {
+ err = DataModel::Decode(reader, endSystime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace EnergyMeasurementStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Accuracy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, accuracy);
+ case Attributes::CumulativeEnergyImported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, cumulativeEnergyImported);
+ case Attributes::CumulativeEnergyExported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, cumulativeEnergyExported);
+ case Attributes::PeriodicEnergyImported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, periodicEnergyImported);
+ case Attributes::PeriodicEnergyExported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, periodicEnergyExported);
+ case Attributes::CumulativeEnergyReset::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, cumulativeEnergyReset);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace CumulativeEnergyMeasured {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyImported), energyImported));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyExported), energyExported));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnergyImported))
+ {
+ err = DataModel::Decode(reader, energyImported);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnergyExported))
+ {
+ err = DataModel::Decode(reader, energyExported);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CumulativeEnergyMeasured.
+namespace PeriodicEnergyMeasured {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyImported), energyImported));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyExported), energyExported));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnergyImported))
+ {
+ err = DataModel::Decode(reader, energyImported);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnergyExported))
+ {
+ err = DataModel::Decode(reader, energyExported);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PeriodicEnergyMeasured.
+} // namespace Events
+
+} // namespace ElectricalEnergyMeasurement
+namespace WaterHeaterManagement {
+namespace Structs {
+
+namespace WaterHeaterBoostInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kOneShot), oneShot);
+ encoder.Encode(to_underlying(Fields::kEmergencyBoost), emergencyBoost);
+ encoder.Encode(to_underlying(Fields::kTemporarySetpoint), temporarySetpoint);
+ encoder.Encode(to_underlying(Fields::kTargetPercentage), targetPercentage);
+ encoder.Encode(to_underlying(Fields::kTargetReheat), targetReheat);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kOneShot))
+ {
+ err = DataModel::Decode(reader, oneShot);
+ }
+ else if (__context_tag == to_underlying(Fields::kEmergencyBoost))
+ {
+ err = DataModel::Decode(reader, emergencyBoost);
+ }
+ else if (__context_tag == to_underlying(Fields::kTemporarySetpoint))
+ {
+ err = DataModel::Decode(reader, temporarySetpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargetPercentage))
+ {
+ err = DataModel::Decode(reader, targetPercentage);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargetReheat))
+ {
+ err = DataModel::Decode(reader, targetReheat);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace WaterHeaterBoostInfoStruct
+} // namespace Structs
+
+namespace Commands {
+namespace Boost {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kBoostInfo), boostInfo);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kBoostInfo))
+ {
+ err = DataModel::Decode(reader, boostInfo);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Boost.
+namespace CancelBoost {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace CancelBoost.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::HeaterTypes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, heaterTypes);
+ case Attributes::HeatDemand::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, heatDemand);
+ case Attributes::TankVolume::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tankVolume);
+ case Attributes::EstimatedHeatRequired::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, estimatedHeatRequired);
+ case Attributes::TankPercentage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tankPercentage);
+ case Attributes::BoostState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, boostState);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace BoostStarted {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBoostInfo), boostInfo));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kBoostInfo))
+ {
+ err = DataModel::Decode(reader, boostInfo);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace BoostStarted.
+namespace BoostEnded {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace BoostEnded.
+} // namespace Events
+
+} // namespace WaterHeaterManagement
+namespace DemandResponseLoadControl {
+namespace Structs {
+
+namespace HeatingSourceControlStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHeatingSource), heatingSource);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHeatingSource))
+ {
+ err = DataModel::Decode(reader, heatingSource);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace HeatingSourceControlStruct
+
+namespace PowerSavingsControlStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPowerSavings), powerSavings);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPowerSavings))
+ {
+ err = DataModel::Decode(reader, powerSavings);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PowerSavingsControlStruct
+
+namespace DutyCycleControlStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDutyCycle), dutyCycle);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDutyCycle))
+ {
+ err = DataModel::Decode(reader, dutyCycle);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace DutyCycleControlStruct
+
+namespace AverageLoadControlStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLoadAdjustment), loadAdjustment);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLoadAdjustment))
+ {
+ err = DataModel::Decode(reader, loadAdjustment);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AverageLoadControlStruct
+
+namespace TemperatureControlStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCoolingTempOffset), coolingTempOffset);
+ encoder.Encode(to_underlying(Fields::kHeatingtTempOffset), heatingtTempOffset);
+ encoder.Encode(to_underlying(Fields::kCoolingTempSetpoint), coolingTempSetpoint);
+ encoder.Encode(to_underlying(Fields::kHeatingTempSetpoint), heatingTempSetpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCoolingTempOffset))
+ {
+ err = DataModel::Decode(reader, coolingTempOffset);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatingtTempOffset))
+ {
+ err = DataModel::Decode(reader, heatingtTempOffset);
+ }
+ else if (__context_tag == to_underlying(Fields::kCoolingTempSetpoint))
+ {
+ err = DataModel::Decode(reader, coolingTempSetpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatingTempSetpoint))
+ {
+ err = DataModel::Decode(reader, heatingTempSetpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TemperatureControlStruct
+
+namespace LoadControlEventTransitionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kControl), control);
+ encoder.Encode(to_underlying(Fields::kTemperatureControl), temperatureControl);
+ encoder.Encode(to_underlying(Fields::kAverageLoadControl), averageLoadControl);
+ encoder.Encode(to_underlying(Fields::kDutyCycleControl), dutyCycleControl);
+ encoder.Encode(to_underlying(Fields::kPowerSavingsControl), powerSavingsControl);
+ encoder.Encode(to_underlying(Fields::kHeatingSourceControl), heatingSourceControl);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kControl))
+ {
+ err = DataModel::Decode(reader, control);
+ }
+ else if (__context_tag == to_underlying(Fields::kTemperatureControl))
+ {
+ err = DataModel::Decode(reader, temperatureControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kAverageLoadControl))
+ {
+ err = DataModel::Decode(reader, averageLoadControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kDutyCycleControl))
+ {
+ err = DataModel::Decode(reader, dutyCycleControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kPowerSavingsControl))
+ {
+ err = DataModel::Decode(reader, powerSavingsControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatingSourceControl))
+ {
+ err = DataModel::Decode(reader, heatingSourceControl);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LoadControlEventTransitionStruct
+
+namespace LoadControlEventStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEventID), eventID);
+ encoder.Encode(to_underlying(Fields::kProgramID), programID);
+ encoder.Encode(to_underlying(Fields::kControl), control);
+ encoder.Encode(to_underlying(Fields::kDeviceClass), deviceClass);
+ encoder.Encode(to_underlying(Fields::kEnrollmentGroup), enrollmentGroup);
+ encoder.Encode(to_underlying(Fields::kCriticality), criticality);
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kTransitions), transitions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEventID))
+ {
+ err = DataModel::Decode(reader, eventID);
+ }
+ else if (__context_tag == to_underlying(Fields::kProgramID))
+ {
+ err = DataModel::Decode(reader, programID);
+ }
+ else if (__context_tag == to_underlying(Fields::kControl))
+ {
+ err = DataModel::Decode(reader, control);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeviceClass))
+ {
+ err = DataModel::Decode(reader, deviceClass);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnrollmentGroup))
+ {
+ err = DataModel::Decode(reader, enrollmentGroup);
+ }
+ else if (__context_tag == to_underlying(Fields::kCriticality))
+ {
+ err = DataModel::Decode(reader, criticality);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitions))
+ {
+ err = DataModel::Decode(reader, transitions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LoadControlEventStruct
+
+namespace LoadControlProgramStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProgramID), programID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kEnrollmentGroup), enrollmentGroup);
+ encoder.Encode(to_underlying(Fields::kRandomStartMinutes), randomStartMinutes);
+ encoder.Encode(to_underlying(Fields::kRandomDurationMinutes), randomDurationMinutes);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProgramID))
+ {
+ err = DataModel::Decode(reader, programID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnrollmentGroup))
+ {
+ err = DataModel::Decode(reader, enrollmentGroup);
+ }
+ else if (__context_tag == to_underlying(Fields::kRandomStartMinutes))
+ {
+ err = DataModel::Decode(reader, randomStartMinutes);
+ }
+ else if (__context_tag == to_underlying(Fields::kRandomDurationMinutes))
+ {
+ err = DataModel::Decode(reader, randomDurationMinutes);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LoadControlProgramStruct
+} // namespace Structs
+
+namespace Commands {
+namespace RegisterLoadControlProgramRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLoadControlProgram), loadControlProgram);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLoadControlProgram))
+ {
+ err = DataModel::Decode(reader, loadControlProgram);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RegisterLoadControlProgramRequest.
+namespace UnregisterLoadControlProgramRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLoadControlProgramID), loadControlProgramID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLoadControlProgramID))
+ {
+ err = DataModel::Decode(reader, loadControlProgramID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UnregisterLoadControlProgramRequest.
+namespace AddLoadControlEventRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEvent), event);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEvent))
+ {
+ err = DataModel::Decode(reader, event);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddLoadControlEventRequest.
+namespace RemoveLoadControlEventRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEventID), eventID);
+ encoder.Encode(to_underlying(Fields::kCancelControl), cancelControl);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEventID))
+ {
+ err = DataModel::Decode(reader, eventID);
+ }
+ else if (__context_tag == to_underlying(Fields::kCancelControl))
+ {
+ err = DataModel::Decode(reader, cancelControl);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveLoadControlEventRequest.
+namespace ClearLoadControlEventsRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ClearLoadControlEventsRequest.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::LoadControlPrograms::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, loadControlPrograms);
+ case Attributes::NumberOfLoadControlPrograms::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfLoadControlPrograms);
+ case Attributes::Events::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, events);
+ case Attributes::ActiveEvents::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeEvents);
+ case Attributes::NumberOfEventsPerProgram::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfEventsPerProgram);
+ case Attributes::NumberOfTransitions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfTransitions);
+ case Attributes::DefaultRandomStart::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultRandomStart);
+ case Attributes::DefaultRandomDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultRandomDuration);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace LoadControlEventStatusChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEventID), eventID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTransitionIndex), transitionIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStatus), status));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCriticality), criticality));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kControl), control));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTemperatureControl), temperatureControl));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAverageLoadControl), averageLoadControl));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDutyCycleControl), dutyCycleControl));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPowerSavingsControl), powerSavingsControl));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kHeatingSourceControl), heatingSourceControl));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEventID))
+ {
+ err = DataModel::Decode(reader, eventID);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionIndex))
+ {
+ err = DataModel::Decode(reader, transitionIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kCriticality))
+ {
+ err = DataModel::Decode(reader, criticality);
+ }
+ else if (__context_tag == to_underlying(Fields::kControl))
+ {
+ err = DataModel::Decode(reader, control);
+ }
+ else if (__context_tag == to_underlying(Fields::kTemperatureControl))
+ {
+ err = DataModel::Decode(reader, temperatureControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kAverageLoadControl))
+ {
+ err = DataModel::Decode(reader, averageLoadControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kDutyCycleControl))
+ {
+ err = DataModel::Decode(reader, dutyCycleControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kPowerSavingsControl))
+ {
+ err = DataModel::Decode(reader, powerSavingsControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatingSourceControl))
+ {
+ err = DataModel::Decode(reader, heatingSourceControl);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LoadControlEventStatusChange.
+} // namespace Events
+
+} // namespace DemandResponseLoadControl
+namespace Messages {
+namespace Structs {
+
+namespace MessageResponseOptionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMessageResponseID), messageResponseID);
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageResponseID))
+ {
+ err = DataModel::Decode(reader, messageResponseID);
+ }
+ else if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MessageResponseOptionStruct
+
+namespace MessageStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMessageID), messageID);
+ encoder.Encode(to_underlying(Fields::kPriority), priority);
+ encoder.Encode(to_underlying(Fields::kMessageControl), messageControl);
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kMessageText), messageText);
+ encoder.Encode(to_underlying(Fields::kResponses), responses);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageID))
+ {
+ err = DataModel::Decode(reader, messageID);
+ }
+ else if (__context_tag == to_underlying(Fields::kPriority))
+ {
+ err = DataModel::Decode(reader, priority);
+ }
+ else if (__context_tag == to_underlying(Fields::kMessageControl))
+ {
+ err = DataModel::Decode(reader, messageControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kMessageText))
+ {
+ err = DataModel::Decode(reader, messageText);
+ }
+ else if (__context_tag == to_underlying(Fields::kResponses))
+ {
+ err = DataModel::Decode(reader, responses);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MessageStruct
+} // namespace Structs
+
+namespace Commands {
+namespace PresentMessagesRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMessageID), messageID);
+ encoder.Encode(to_underlying(Fields::kPriority), priority);
+ encoder.Encode(to_underlying(Fields::kMessageControl), messageControl);
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kMessageText), messageText);
+ encoder.Encode(to_underlying(Fields::kResponses), responses);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageID))
+ {
+ err = DataModel::Decode(reader, messageID);
+ }
+ else if (__context_tag == to_underlying(Fields::kPriority))
+ {
+ err = DataModel::Decode(reader, priority);
+ }
+ else if (__context_tag == to_underlying(Fields::kMessageControl))
+ {
+ err = DataModel::Decode(reader, messageControl);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kMessageText))
+ {
+ err = DataModel::Decode(reader, messageText);
+ }
+ else if (__context_tag == to_underlying(Fields::kResponses))
+ {
+ err = DataModel::Decode(reader, responses);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PresentMessagesRequest.
+namespace CancelMessagesRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMessageIDs), messageIDs);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageIDs))
+ {
+ err = DataModel::Decode(reader, messageIDs);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CancelMessagesRequest.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Messages::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, messages);
+ case Attributes::ActiveMessageIDs::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeMessageIDs);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace MessageQueued {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMessageID), messageID));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageID))
+ {
+ err = DataModel::Decode(reader, messageID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MessageQueued.
+namespace MessagePresented {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMessageID), messageID));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageID))
+ {
+ err = DataModel::Decode(reader, messageID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MessagePresented.
+namespace MessageComplete {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMessageID), messageID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kResponseID), responseID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReply), reply));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFutureMessagesPreference), futureMessagesPreference));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMessageID))
+ {
+ err = DataModel::Decode(reader, messageID);
+ }
+ else if (__context_tag == to_underlying(Fields::kResponseID))
+ {
+ err = DataModel::Decode(reader, responseID);
+ }
+ else if (__context_tag == to_underlying(Fields::kReply))
+ {
+ err = DataModel::Decode(reader, reply);
+ }
+ else if (__context_tag == to_underlying(Fields::kFutureMessagesPreference))
+ {
+ err = DataModel::Decode(reader, futureMessagesPreference);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MessageComplete.
+} // namespace Events
+
+} // namespace Messages
+namespace DeviceEnergyManagement {
+namespace Structs {
+
+namespace CostStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCostType), costType);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ encoder.Encode(to_underlying(Fields::kDecimalPoints), decimalPoints);
+ encoder.Encode(to_underlying(Fields::kCurrency), currency);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCostType))
+ {
+ err = DataModel::Decode(reader, costType);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else if (__context_tag == to_underlying(Fields::kDecimalPoints))
+ {
+ err = DataModel::Decode(reader, decimalPoints);
+ }
+ else if (__context_tag == to_underlying(Fields::kCurrency))
+ {
+ err = DataModel::Decode(reader, currency);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace CostStruct
+
+namespace PowerAdjustStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMinPower), minPower);
+ encoder.Encode(to_underlying(Fields::kMaxPower), maxPower);
+ encoder.Encode(to_underlying(Fields::kMinDuration), minDuration);
+ encoder.Encode(to_underlying(Fields::kMaxDuration), maxDuration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMinPower))
+ {
+ err = DataModel::Decode(reader, minPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxPower))
+ {
+ err = DataModel::Decode(reader, maxPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinDuration))
+ {
+ err = DataModel::Decode(reader, minDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxDuration))
+ {
+ err = DataModel::Decode(reader, maxDuration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PowerAdjustStruct
+
+namespace PowerAdjustCapabilityStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPowerAdjustCapability), powerAdjustCapability);
+ encoder.Encode(to_underlying(Fields::kCause), cause);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPowerAdjustCapability))
+ {
+ err = DataModel::Decode(reader, powerAdjustCapability);
+ }
+ else if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PowerAdjustCapabilityStruct
+
+namespace SlotStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMinDuration), minDuration);
+ encoder.Encode(to_underlying(Fields::kMaxDuration), maxDuration);
+ encoder.Encode(to_underlying(Fields::kDefaultDuration), defaultDuration);
+ encoder.Encode(to_underlying(Fields::kElapsedSlotTime), elapsedSlotTime);
+ encoder.Encode(to_underlying(Fields::kRemainingSlotTime), remainingSlotTime);
+ encoder.Encode(to_underlying(Fields::kSlotIsPausable), slotIsPausable);
+ encoder.Encode(to_underlying(Fields::kMinPauseDuration), minPauseDuration);
+ encoder.Encode(to_underlying(Fields::kMaxPauseDuration), maxPauseDuration);
+ encoder.Encode(to_underlying(Fields::kManufacturerESAState), manufacturerESAState);
+ encoder.Encode(to_underlying(Fields::kNominalPower), nominalPower);
+ encoder.Encode(to_underlying(Fields::kMinPower), minPower);
+ encoder.Encode(to_underlying(Fields::kMaxPower), maxPower);
+ encoder.Encode(to_underlying(Fields::kNominalEnergy), nominalEnergy);
+ encoder.Encode(to_underlying(Fields::kCosts), costs);
+ encoder.Encode(to_underlying(Fields::kMinPowerAdjustment), minPowerAdjustment);
+ encoder.Encode(to_underlying(Fields::kMaxPowerAdjustment), maxPowerAdjustment);
+ encoder.Encode(to_underlying(Fields::kMinDurationAdjustment), minDurationAdjustment);
+ encoder.Encode(to_underlying(Fields::kMaxDurationAdjustment), maxDurationAdjustment);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMinDuration))
+ {
+ err = DataModel::Decode(reader, minDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxDuration))
+ {
+ err = DataModel::Decode(reader, maxDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kDefaultDuration))
+ {
+ err = DataModel::Decode(reader, defaultDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kElapsedSlotTime))
+ {
+ err = DataModel::Decode(reader, elapsedSlotTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kRemainingSlotTime))
+ {
+ err = DataModel::Decode(reader, remainingSlotTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kSlotIsPausable))
+ {
+ err = DataModel::Decode(reader, slotIsPausable);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinPauseDuration))
+ {
+ err = DataModel::Decode(reader, minPauseDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxPauseDuration))
+ {
+ err = DataModel::Decode(reader, maxPauseDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kManufacturerESAState))
+ {
+ err = DataModel::Decode(reader, manufacturerESAState);
+ }
+ else if (__context_tag == to_underlying(Fields::kNominalPower))
+ {
+ err = DataModel::Decode(reader, nominalPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinPower))
+ {
+ err = DataModel::Decode(reader, minPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxPower))
+ {
+ err = DataModel::Decode(reader, maxPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kNominalEnergy))
+ {
+ err = DataModel::Decode(reader, nominalEnergy);
+ }
+ else if (__context_tag == to_underlying(Fields::kCosts))
+ {
+ err = DataModel::Decode(reader, costs);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinPowerAdjustment))
+ {
+ err = DataModel::Decode(reader, minPowerAdjustment);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxPowerAdjustment))
+ {
+ err = DataModel::Decode(reader, maxPowerAdjustment);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinDurationAdjustment))
+ {
+ err = DataModel::Decode(reader, minDurationAdjustment);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxDurationAdjustment))
+ {
+ err = DataModel::Decode(reader, maxDurationAdjustment);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SlotStruct
+
+namespace ForecastStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kForecastID), forecastID);
+ encoder.Encode(to_underlying(Fields::kActiveSlotNumber), activeSlotNumber);
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kEndTime), endTime);
+ encoder.Encode(to_underlying(Fields::kEarliestStartTime), earliestStartTime);
+ encoder.Encode(to_underlying(Fields::kLatestEndTime), latestEndTime);
+ encoder.Encode(to_underlying(Fields::kIsPausable), isPausable);
+ encoder.Encode(to_underlying(Fields::kSlots), slots);
+ encoder.Encode(to_underlying(Fields::kForecastUpdateReason), forecastUpdateReason);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kForecastID))
+ {
+ err = DataModel::Decode(reader, forecastID);
+ }
+ else if (__context_tag == to_underlying(Fields::kActiveSlotNumber))
+ {
+ err = DataModel::Decode(reader, activeSlotNumber);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndTime))
+ {
+ err = DataModel::Decode(reader, endTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEarliestStartTime))
+ {
+ err = DataModel::Decode(reader, earliestStartTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kLatestEndTime))
+ {
+ err = DataModel::Decode(reader, latestEndTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kIsPausable))
+ {
+ err = DataModel::Decode(reader, isPausable);
+ }
+ else if (__context_tag == to_underlying(Fields::kSlots))
+ {
+ err = DataModel::Decode(reader, slots);
+ }
+ else if (__context_tag == to_underlying(Fields::kForecastUpdateReason))
+ {
+ err = DataModel::Decode(reader, forecastUpdateReason);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ForecastStruct
+
+namespace ConstraintsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kNominalPower), nominalPower);
+ encoder.Encode(to_underlying(Fields::kMaximumEnergy), maximumEnergy);
+ encoder.Encode(to_underlying(Fields::kLoadControl), loadControl);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kNominalPower))
+ {
+ err = DataModel::Decode(reader, nominalPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaximumEnergy))
+ {
+ err = DataModel::Decode(reader, maximumEnergy);
+ }
+ else if (__context_tag == to_underlying(Fields::kLoadControl))
+ {
+ err = DataModel::Decode(reader, loadControl);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ConstraintsStruct
+
+namespace SlotAdjustmentStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSlotIndex), slotIndex);
+ encoder.Encode(to_underlying(Fields::kNominalPower), nominalPower);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSlotIndex))
+ {
+ err = DataModel::Decode(reader, slotIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kNominalPower))
+ {
+ err = DataModel::Decode(reader, nominalPower);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SlotAdjustmentStruct
+} // namespace Structs
+
+namespace Commands {
+namespace PowerAdjustRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPower), power);
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kCause), cause);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPower))
+ {
+ err = DataModel::Decode(reader, power);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PowerAdjustRequest.
+namespace CancelPowerAdjustRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace CancelPowerAdjustRequest.
+namespace StartTimeAdjustRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRequestedStartTime), requestedStartTime);
+ encoder.Encode(to_underlying(Fields::kCause), cause);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRequestedStartTime))
+ {
+ err = DataModel::Decode(reader, requestedStartTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StartTimeAdjustRequest.
+namespace PauseRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDuration), duration);
+ encoder.Encode(to_underlying(Fields::kCause), cause);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PauseRequest.
+namespace ResumeRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResumeRequest.
+namespace ModifyForecastRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kForecastID), forecastID);
+ encoder.Encode(to_underlying(Fields::kSlotAdjustments), slotAdjustments);
+ encoder.Encode(to_underlying(Fields::kCause), cause);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kForecastID))
+ {
+ err = DataModel::Decode(reader, forecastID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSlotAdjustments))
+ {
+ err = DataModel::Decode(reader, slotAdjustments);
+ }
+ else if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ModifyForecastRequest.
+namespace RequestConstraintBasedForecast {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kConstraints), constraints);
+ encoder.Encode(to_underlying(Fields::kCause), cause);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kConstraints))
+ {
+ err = DataModel::Decode(reader, constraints);
+ }
+ else if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RequestConstraintBasedForecast.
+namespace CancelRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace CancelRequest.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::ESAType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ESAType);
+ case Attributes::ESACanGenerate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ESACanGenerate);
+ case Attributes::ESAState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ESAState);
+ case Attributes::AbsMinPower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, absMinPower);
+ case Attributes::AbsMaxPower::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, absMaxPower);
+ case Attributes::PowerAdjustmentCapability::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, powerAdjustmentCapability);
+ case Attributes::Forecast::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, forecast);
+ case Attributes::OptOutState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, optOutState);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace PowerAdjustStart {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace PowerAdjustStart.
+namespace PowerAdjustEnd {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCause), cause));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDuration), duration));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyUse), energyUse));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnergyUse))
+ {
+ err = DataModel::Decode(reader, energyUse);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PowerAdjustEnd.
+namespace Paused {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Paused.
+namespace Resumed {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCause), cause));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCause))
+ {
+ err = DataModel::Decode(reader, cause);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Resumed.
+} // namespace Events
+
+} // namespace DeviceEnergyManagement
+namespace EnergyEvse {
+namespace Structs {
+
+namespace ChargingTargetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTargetTimeMinutesPastMidnight), targetTimeMinutesPastMidnight);
+ encoder.Encode(to_underlying(Fields::kTargetSoC), targetSoC);
+ encoder.Encode(to_underlying(Fields::kAddedEnergy), addedEnergy);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTargetTimeMinutesPastMidnight))
+ {
+ err = DataModel::Decode(reader, targetTimeMinutesPastMidnight);
+ }
+ else if (__context_tag == to_underlying(Fields::kTargetSoC))
+ {
+ err = DataModel::Decode(reader, targetSoC);
+ }
+ else if (__context_tag == to_underlying(Fields::kAddedEnergy))
+ {
+ err = DataModel::Decode(reader, addedEnergy);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ChargingTargetStruct
+
+namespace ChargingTargetScheduleStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDayOfWeekForSequence), dayOfWeekForSequence);
+ encoder.Encode(to_underlying(Fields::kChargingTargets), chargingTargets);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDayOfWeekForSequence))
+ {
+ err = DataModel::Decode(reader, dayOfWeekForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kChargingTargets))
+ {
+ err = DataModel::Decode(reader, chargingTargets);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ChargingTargetScheduleStruct
+} // namespace Structs
+
+namespace Commands {
+namespace GetTargetsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kChargingTargetSchedules), chargingTargetSchedules);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kChargingTargetSchedules))
+ {
+ err = DataModel::Decode(reader, chargingTargetSchedules);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetTargetsResponse.
+namespace Disable {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Disable.
+namespace EnableCharging {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kChargingEnabledUntil), chargingEnabledUntil);
+ encoder.Encode(to_underlying(Fields::kMinimumChargeCurrent), minimumChargeCurrent);
+ encoder.Encode(to_underlying(Fields::kMaximumChargeCurrent), maximumChargeCurrent);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kChargingEnabledUntil))
+ {
+ err = DataModel::Decode(reader, chargingEnabledUntil);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinimumChargeCurrent))
+ {
+ err = DataModel::Decode(reader, minimumChargeCurrent);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaximumChargeCurrent))
+ {
+ err = DataModel::Decode(reader, maximumChargeCurrent);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnableCharging.
+namespace EnableDischarging {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDischargingEnabledUntil), dischargingEnabledUntil);
+ encoder.Encode(to_underlying(Fields::kMaximumDischargeCurrent), maximumDischargeCurrent);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDischargingEnabledUntil))
+ {
+ err = DataModel::Decode(reader, dischargingEnabledUntil);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaximumDischargeCurrent))
+ {
+ err = DataModel::Decode(reader, maximumDischargeCurrent);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnableDischarging.
+namespace StartDiagnostics {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace StartDiagnostics.
+namespace SetTargets {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kChargingTargetSchedules), chargingTargetSchedules);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kChargingTargetSchedules))
+ {
+ err = DataModel::Decode(reader, chargingTargetSchedules);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetTargets.
+namespace GetTargets {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace GetTargets.
+namespace ClearTargets {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ClearTargets.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::State::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, state);
+ case Attributes::SupplyState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supplyState);
+ case Attributes::FaultState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, faultState);
+ case Attributes::ChargingEnabledUntil::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, chargingEnabledUntil);
+ case Attributes::DischargingEnabledUntil::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, dischargingEnabledUntil);
+ case Attributes::CircuitCapacity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, circuitCapacity);
+ case Attributes::MinimumChargeCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minimumChargeCurrent);
+ case Attributes::MaximumChargeCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maximumChargeCurrent);
+ case Attributes::MaximumDischargeCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maximumDischargeCurrent);
+ case Attributes::UserMaximumChargeCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, userMaximumChargeCurrent);
+ case Attributes::RandomizationDelayWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, randomizationDelayWindow);
+ case Attributes::NextChargeStartTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nextChargeStartTime);
+ case Attributes::NextChargeTargetTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nextChargeTargetTime);
+ case Attributes::NextChargeRequiredEnergy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nextChargeRequiredEnergy);
+ case Attributes::NextChargeTargetSoC::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nextChargeTargetSoC);
+ case Attributes::ApproximateEVEfficiency::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, approximateEVEfficiency);
+ case Attributes::StateOfCharge::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, stateOfCharge);
+ case Attributes::BatteryCapacity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, batteryCapacity);
+ case Attributes::VehicleID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vehicleID);
+ case Attributes::SessionID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sessionID);
+ case Attributes::SessionDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sessionDuration);
+ case Attributes::SessionEnergyCharged::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sessionEnergyCharged);
+ case Attributes::SessionEnergyDischarged::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sessionEnergyDischarged);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace EVConnected {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSessionID))
+ {
+ err = DataModel::Decode(reader, sessionID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EVConnected.
+namespace EVNotDetected {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionDuration), sessionDuration));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyCharged), sessionEnergyCharged));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyDischarged), sessionEnergyDischarged));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSessionID))
+ {
+ err = DataModel::Decode(reader, sessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else if (__context_tag == to_underlying(Fields::kSessionDuration))
+ {
+ err = DataModel::Decode(reader, sessionDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kSessionEnergyCharged))
+ {
+ err = DataModel::Decode(reader, sessionEnergyCharged);
+ }
+ else if (__context_tag == to_underlying(Fields::kSessionEnergyDischarged))
+ {
+ err = DataModel::Decode(reader, sessionEnergyDischarged);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EVNotDetected.
+namespace EnergyTransferStarted {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumCurrent), maximumCurrent));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumDischargeCurrent), maximumDischargeCurrent));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSessionID))
+ {
+ err = DataModel::Decode(reader, sessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaximumCurrent))
+ {
+ err = DataModel::Decode(reader, maximumCurrent);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaximumDischargeCurrent))
+ {
+ err = DataModel::Decode(reader, maximumDischargeCurrent);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnergyTransferStarted.
+namespace EnergyTransferStopped {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyTransferred), energyTransferred));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyDischarged), energyDischarged));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSessionID))
+ {
+ err = DataModel::Decode(reader, sessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else if (__context_tag == to_underlying(Fields::kReason))
+ {
+ err = DataModel::Decode(reader, reason);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnergyTransferred))
+ {
+ err = DataModel::Decode(reader, energyTransferred);
+ }
+ else if (__context_tag == to_underlying(Fields::kEnergyDischarged))
+ {
+ err = DataModel::Decode(reader, energyDischarged);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnergyTransferStopped.
+namespace Fault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStatePreviousState), faultStatePreviousState));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStateCurrentState), faultStateCurrentState));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSessionID))
+ {
+ err = DataModel::Decode(reader, sessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kState))
+ {
+ err = DataModel::Decode(reader, state);
+ }
+ else if (__context_tag == to_underlying(Fields::kFaultStatePreviousState))
+ {
+ err = DataModel::Decode(reader, faultStatePreviousState);
+ }
+ else if (__context_tag == to_underlying(Fields::kFaultStateCurrentState))
+ {
+ err = DataModel::Decode(reader, faultStateCurrentState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Fault.
+namespace Rfid {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUid), uid));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUid))
+ {
+ err = DataModel::Decode(reader, uid);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Rfid.
+} // namespace Events
+
+} // namespace EnergyEvse
+namespace EnergyPreference {
+namespace Structs {
+
+namespace BalanceStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStep), step);
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStep))
+ {
+ err = DataModel::Decode(reader, step);
+ }
+ else if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace BalanceStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::EnergyBalances::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, energyBalances);
+ case Attributes::CurrentEnergyBalance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentEnergyBalance);
+ case Attributes::EnergyPriorities::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, energyPriorities);
+ case Attributes::LowPowerModeSensitivities::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lowPowerModeSensitivities);
+ case Attributes::CurrentLowPowerModeSensitivity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentLowPowerModeSensitivity);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace EnergyPreference
+namespace PowerTopology {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::AvailableEndpoints::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, availableEndpoints);
+ case Attributes::ActiveEndpoints::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeEndpoints);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace PowerTopology
+namespace EnergyEvseMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace EnergyEvseMode
+namespace WaterHeaterMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace WaterHeaterMode
+namespace DeviceEnergyManagementMode {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace ChangeToMode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewMode), newMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewMode))
+ {
+ err = DataModel::Decode(reader, newMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToMode.
+namespace ChangeToModeResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeToModeResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedModes);
+ case Attributes::CurrentMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace DeviceEnergyManagementMode
+namespace DoorLock {
+namespace Structs {
+
+namespace CredentialStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCredentialType), credentialType);
+ encoder.Encode(to_underlying(Fields::kCredentialIndex), credentialIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCredentialType))
+ {
+ err = DataModel::Decode(reader, credentialType);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentialIndex))
+ {
+ err = DataModel::Decode(reader, credentialIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace CredentialStruct
+} // namespace Structs
+
+namespace Commands {
+namespace LockDoor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPINCode))
+ {
+ err = DataModel::Decode(reader, PINCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LockDoor.
+namespace UnlockDoor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPINCode))
+ {
+ err = DataModel::Decode(reader, PINCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UnlockDoor.
+namespace UnlockWithTimeout {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTimeout), timeout);
+ encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTimeout))
+ {
+ err = DataModel::Decode(reader, timeout);
+ }
+ else if (__context_tag == to_underlying(Fields::kPINCode))
+ {
+ err = DataModel::Decode(reader, PINCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UnlockWithTimeout.
+namespace SetWeekDaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kDaysMask), daysMask);
+ encoder.Encode(to_underlying(Fields::kStartHour), startHour);
+ encoder.Encode(to_underlying(Fields::kStartMinute), startMinute);
+ encoder.Encode(to_underlying(Fields::kEndHour), endHour);
+ encoder.Encode(to_underlying(Fields::kEndMinute), endMinute);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWeekDayIndex))
+ {
+ err = DataModel::Decode(reader, weekDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kDaysMask))
+ {
+ err = DataModel::Decode(reader, daysMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartHour))
+ {
+ err = DataModel::Decode(reader, startHour);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartMinute))
+ {
+ err = DataModel::Decode(reader, startMinute);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndHour))
+ {
+ err = DataModel::Decode(reader, endHour);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndMinute))
+ {
+ err = DataModel::Decode(reader, endMinute);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetWeekDaySchedule.
+namespace GetWeekDaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWeekDayIndex))
+ {
+ err = DataModel::Decode(reader, weekDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetWeekDaySchedule.
+namespace GetWeekDayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kDaysMask), daysMask);
+ encoder.Encode(to_underlying(Fields::kStartHour), startHour);
+ encoder.Encode(to_underlying(Fields::kStartMinute), startMinute);
+ encoder.Encode(to_underlying(Fields::kEndHour), endHour);
+ encoder.Encode(to_underlying(Fields::kEndMinute), endMinute);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWeekDayIndex))
+ {
+ err = DataModel::Decode(reader, weekDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kDaysMask))
+ {
+ err = DataModel::Decode(reader, daysMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartHour))
+ {
+ err = DataModel::Decode(reader, startHour);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartMinute))
+ {
+ err = DataModel::Decode(reader, startMinute);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndHour))
+ {
+ err = DataModel::Decode(reader, endHour);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndMinute))
+ {
+ err = DataModel::Decode(reader, endMinute);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetWeekDayScheduleResponse.
+namespace ClearWeekDaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWeekDayIndex))
+ {
+ err = DataModel::Decode(reader, weekDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ClearWeekDaySchedule.
+namespace SetYearDaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
+ encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kYearDayIndex))
+ {
+ err = DataModel::Decode(reader, yearDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalStartTime))
+ {
+ err = DataModel::Decode(reader, localStartTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalEndTime))
+ {
+ err = DataModel::Decode(reader, localEndTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetYearDaySchedule.
+namespace GetYearDaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kYearDayIndex))
+ {
+ err = DataModel::Decode(reader, yearDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetYearDaySchedule.
+namespace GetYearDayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
+ encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kYearDayIndex))
+ {
+ err = DataModel::Decode(reader, yearDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalStartTime))
+ {
+ err = DataModel::Decode(reader, localStartTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalEndTime))
+ {
+ err = DataModel::Decode(reader, localEndTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetYearDayScheduleResponse.
+namespace ClearYearDaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kYearDayIndex))
+ {
+ err = DataModel::Decode(reader, yearDayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ClearYearDaySchedule.
+namespace SetHolidaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
+ encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
+ encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
+ encoder.Encode(to_underlying(Fields::kOperatingMode), operatingMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHolidayIndex))
+ {
+ err = DataModel::Decode(reader, holidayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalStartTime))
+ {
+ err = DataModel::Decode(reader, localStartTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalEndTime))
+ {
+ err = DataModel::Decode(reader, localEndTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperatingMode))
+ {
+ err = DataModel::Decode(reader, operatingMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetHolidaySchedule.
+namespace GetHolidaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHolidayIndex))
+ {
+ err = DataModel::Decode(reader, holidayIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetHolidaySchedule.
+namespace GetHolidayScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
+ encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
+ encoder.Encode(to_underlying(Fields::kOperatingMode), operatingMode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHolidayIndex))
+ {
+ err = DataModel::Decode(reader, holidayIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalStartTime))
+ {
+ err = DataModel::Decode(reader, localStartTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocalEndTime))
+ {
+ err = DataModel::Decode(reader, localEndTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperatingMode))
+ {
+ err = DataModel::Decode(reader, operatingMode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetHolidayScheduleResponse.
+namespace ClearHolidaySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHolidayIndex))
+ {
+ err = DataModel::Decode(reader, holidayIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ClearHolidaySchedule.
+namespace SetUser {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperationType), operationType);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kUserName), userName);
+ encoder.Encode(to_underlying(Fields::kUserUniqueID), userUniqueID);
+ encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
+ encoder.Encode(to_underlying(Fields::kUserType), userType);
+ encoder.Encode(to_underlying(Fields::kCredentialRule), credentialRule);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperationType))
+ {
+ err = DataModel::Decode(reader, operationType);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserName))
+ {
+ err = DataModel::Decode(reader, userName);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserUniqueID))
+ {
+ err = DataModel::Decode(reader, userUniqueID);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserStatus))
+ {
+ err = DataModel::Decode(reader, userStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserType))
+ {
+ err = DataModel::Decode(reader, userType);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentialRule))
+ {
+ err = DataModel::Decode(reader, credentialRule);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetUser.
+namespace GetUser {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetUser.
+namespace GetUserResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kUserName), userName);
+ encoder.Encode(to_underlying(Fields::kUserUniqueID), userUniqueID);
+ encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
+ encoder.Encode(to_underlying(Fields::kUserType), userType);
+ encoder.Encode(to_underlying(Fields::kCredentialRule), credentialRule);
+ encoder.Encode(to_underlying(Fields::kCredentials), credentials);
+ encoder.Encode(to_underlying(Fields::kCreatorFabricIndex), creatorFabricIndex);
+ encoder.Encode(to_underlying(Fields::kLastModifiedFabricIndex), lastModifiedFabricIndex);
+ encoder.Encode(to_underlying(Fields::kNextUserIndex), nextUserIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserName))
+ {
+ err = DataModel::Decode(reader, userName);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserUniqueID))
+ {
+ err = DataModel::Decode(reader, userUniqueID);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserStatus))
+ {
+ err = DataModel::Decode(reader, userStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserType))
+ {
+ err = DataModel::Decode(reader, userType);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentialRule))
+ {
+ err = DataModel::Decode(reader, credentialRule);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentials))
+ {
+ err = DataModel::Decode(reader, credentials);
+ }
+ else if (__context_tag == to_underlying(Fields::kCreatorFabricIndex))
+ {
+ err = DataModel::Decode(reader, creatorFabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kLastModifiedFabricIndex))
+ {
+ err = DataModel::Decode(reader, lastModifiedFabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kNextUserIndex))
+ {
+ err = DataModel::Decode(reader, nextUserIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetUserResponse.
+namespace ClearUser {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ClearUser.
+namespace SetCredential {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperationType), operationType);
+ encoder.Encode(to_underlying(Fields::kCredential), credential);
+ encoder.Encode(to_underlying(Fields::kCredentialData), credentialData);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
+ encoder.Encode(to_underlying(Fields::kUserType), userType);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperationType))
+ {
+ err = DataModel::Decode(reader, operationType);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredential))
+ {
+ err = DataModel::Decode(reader, credential);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentialData))
+ {
+ err = DataModel::Decode(reader, credentialData);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserStatus))
+ {
+ err = DataModel::Decode(reader, userStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserType))
+ {
+ err = DataModel::Decode(reader, userType);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetCredential.
+namespace SetCredentialResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kNextCredentialIndex), nextCredentialIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kNextCredentialIndex))
+ {
+ err = DataModel::Decode(reader, nextCredentialIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetCredentialResponse.
+namespace GetCredentialStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCredential), credential);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCredential))
+ {
+ err = DataModel::Decode(reader, credential);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetCredentialStatus.
+namespace GetCredentialStatusResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCredentialExists), credentialExists);
+ encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
+ encoder.Encode(to_underlying(Fields::kCreatorFabricIndex), creatorFabricIndex);
+ encoder.Encode(to_underlying(Fields::kLastModifiedFabricIndex), lastModifiedFabricIndex);
+ encoder.Encode(to_underlying(Fields::kNextCredentialIndex), nextCredentialIndex);
+ encoder.Encode(to_underlying(Fields::kCredentialData), credentialData);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCredentialExists))
+ {
+ err = DataModel::Decode(reader, credentialExists);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kCreatorFabricIndex))
+ {
+ err = DataModel::Decode(reader, creatorFabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kLastModifiedFabricIndex))
+ {
+ err = DataModel::Decode(reader, lastModifiedFabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kNextCredentialIndex))
+ {
+ err = DataModel::Decode(reader, nextCredentialIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentialData))
+ {
+ err = DataModel::Decode(reader, credentialData);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetCredentialStatusResponse.
+namespace ClearCredential {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCredential), credential);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCredential))
+ {
+ err = DataModel::Decode(reader, credential);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ClearCredential.
+namespace UnboltDoor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPINCode))
+ {
+ err = DataModel::Decode(reader, PINCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UnboltDoor.
+namespace SetAliroReaderConfig {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSigningKey), signingKey);
+ encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
+ encoder.Encode(to_underlying(Fields::kGroupIdentifier), groupIdentifier);
+ encoder.Encode(to_underlying(Fields::kGroupResolvingKey), groupResolvingKey);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSigningKey))
+ {
+ err = DataModel::Decode(reader, signingKey);
+ }
+ else if (__context_tag == to_underlying(Fields::kVerificationKey))
+ {
+ err = DataModel::Decode(reader, verificationKey);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupIdentifier))
+ {
+ err = DataModel::Decode(reader, groupIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kGroupResolvingKey))
+ {
+ err = DataModel::Decode(reader, groupResolvingKey);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetAliroReaderConfig.
+namespace ClearAliroReaderConfig {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ClearAliroReaderConfig.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::LockState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lockState);
+ case Attributes::LockType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lockType);
+ case Attributes::ActuatorEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, actuatorEnabled);
+ case Attributes::DoorState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, doorState);
+ case Attributes::DoorOpenEvents::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, doorOpenEvents);
+ case Attributes::DoorClosedEvents::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, doorClosedEvents);
+ case Attributes::OpenPeriod::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, openPeriod);
+ case Attributes::NumberOfTotalUsersSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfTotalUsersSupported);
+ case Attributes::NumberOfPINUsersSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfPINUsersSupported);
+ case Attributes::NumberOfRFIDUsersSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfRFIDUsersSupported);
+ case Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfWeekDaySchedulesSupportedPerUser);
+ case Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfYearDaySchedulesSupportedPerUser);
+ case Attributes::NumberOfHolidaySchedulesSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfHolidaySchedulesSupported);
+ case Attributes::MaxPINCodeLength::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxPINCodeLength);
+ case Attributes::MinPINCodeLength::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minPINCodeLength);
+ case Attributes::MaxRFIDCodeLength::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxRFIDCodeLength);
+ case Attributes::MinRFIDCodeLength::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minRFIDCodeLength);
+ case Attributes::CredentialRulesSupport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, credentialRulesSupport);
+ case Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfCredentialsSupportedPerUser);
+ case Attributes::Language::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, language);
+ case Attributes::LEDSettings::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, LEDSettings);
+ case Attributes::AutoRelockTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, autoRelockTime);
+ case Attributes::SoundVolume::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, soundVolume);
+ case Attributes::OperatingMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operatingMode);
+ case Attributes::SupportedOperatingModes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedOperatingModes);
+ case Attributes::DefaultConfigurationRegister::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, defaultConfigurationRegister);
+ case Attributes::EnableLocalProgramming::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enableLocalProgramming);
+ case Attributes::EnableOneTouchLocking::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enableOneTouchLocking);
+ case Attributes::EnableInsideStatusLED::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enableInsideStatusLED);
+ case Attributes::EnablePrivacyModeButton::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enablePrivacyModeButton);
+ case Attributes::LocalProgrammingFeatures::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localProgrammingFeatures);
+ case Attributes::WrongCodeEntryLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, wrongCodeEntryLimit);
+ case Attributes::UserCodeTemporaryDisableTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, userCodeTemporaryDisableTime);
+ case Attributes::SendPINOverTheAir::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sendPINOverTheAir);
+ case Attributes::RequirePINforRemoteOperation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, requirePINforRemoteOperation);
+ case Attributes::ExpiringUserTimeout::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, expiringUserTimeout);
+ case Attributes::AliroReaderVerificationKey::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroReaderVerificationKey);
+ case Attributes::AliroReaderGroupIdentifier::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroReaderGroupIdentifier);
+ case Attributes::AliroReaderGroupSubIdentifier::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroReaderGroupSubIdentifier);
+ case Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroExpeditedTransactionSupportedProtocolVersions);
+ case Attributes::AliroGroupResolvingKey::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroGroupResolvingKey);
+ case Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroSupportedBLEUWBProtocolVersions);
+ case Attributes::AliroBLEAdvertisingVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, aliroBLEAdvertisingVersion);
+ case Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfAliroCredentialIssuerKeysSupported);
+ case Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfAliroEndpointKeysSupported);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace DoorLockAlarm {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmCode), alarmCode));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAlarmCode))
+ {
+ err = DataModel::Decode(reader, alarmCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DoorLockAlarm.
+namespace DoorStateChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDoorState), doorState));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDoorState))
+ {
+ err = DataModel::Decode(reader, doorState);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DoorStateChange.
+namespace LockOperation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kLockOperationType), lockOperationType));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationSource), operationSource));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUserIndex), userIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSourceNode), sourceNode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCredentials), credentials));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLockOperationType))
+ {
+ err = DataModel::Decode(reader, lockOperationType);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperationSource))
+ {
+ err = DataModel::Decode(reader, operationSource);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kSourceNode))
+ {
+ err = DataModel::Decode(reader, sourceNode);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentials))
+ {
+ err = DataModel::Decode(reader, credentials);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LockOperation.
+namespace LockOperationError {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kLockOperationType), lockOperationType));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationSource), operationSource));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationError), operationError));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUserIndex), userIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSourceNode), sourceNode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCredentials), credentials));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLockOperationType))
+ {
+ err = DataModel::Decode(reader, lockOperationType);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperationSource))
+ {
+ err = DataModel::Decode(reader, operationSource);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperationError))
+ {
+ err = DataModel::Decode(reader, operationError);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kSourceNode))
+ {
+ err = DataModel::Decode(reader, sourceNode);
+ }
+ else if (__context_tag == to_underlying(Fields::kCredentials))
+ {
+ err = DataModel::Decode(reader, credentials);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LockOperationError.
+namespace LockUserChange {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kLockDataType), lockDataType));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDataOperationType), dataOperationType));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationSource), operationSource));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUserIndex), userIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSourceNode), sourceNode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDataIndex), dataIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLockDataType))
+ {
+ err = DataModel::Decode(reader, lockDataType);
+ }
+ else if (__context_tag == to_underlying(Fields::kDataOperationType))
+ {
+ err = DataModel::Decode(reader, dataOperationType);
+ }
+ else if (__context_tag == to_underlying(Fields::kOperationSource))
+ {
+ err = DataModel::Decode(reader, operationSource);
+ }
+ else if (__context_tag == to_underlying(Fields::kUserIndex))
+ {
+ err = DataModel::Decode(reader, userIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else if (__context_tag == to_underlying(Fields::kSourceNode))
+ {
+ err = DataModel::Decode(reader, sourceNode);
+ }
+ else if (__context_tag == to_underlying(Fields::kDataIndex))
+ {
+ err = DataModel::Decode(reader, dataIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LockUserChange.
+} // namespace Events
+
+} // namespace DoorLock
+namespace WindowCovering {
+
+namespace Commands {
+namespace UpOrOpen {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace UpOrOpen.
+namespace DownOrClose {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace DownOrClose.
+namespace StopMotion {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace StopMotion.
+namespace GoToLiftValue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLiftValue), liftValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLiftValue))
+ {
+ err = DataModel::Decode(reader, liftValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GoToLiftValue.
+namespace GoToLiftPercentage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLiftPercent100thsValue), liftPercent100thsValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLiftPercent100thsValue))
+ {
+ err = DataModel::Decode(reader, liftPercent100thsValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GoToLiftPercentage.
+namespace GoToTiltValue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTiltValue), tiltValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTiltValue))
+ {
+ err = DataModel::Decode(reader, tiltValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GoToTiltValue.
+namespace GoToTiltPercentage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTiltPercent100thsValue), tiltPercent100thsValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTiltPercent100thsValue))
+ {
+ err = DataModel::Decode(reader, tiltPercent100thsValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GoToTiltPercentage.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Type::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, type);
+ case Attributes::PhysicalClosedLimitLift::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalClosedLimitLift);
+ case Attributes::PhysicalClosedLimitTilt::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalClosedLimitTilt);
+ case Attributes::CurrentPositionLift::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPositionLift);
+ case Attributes::CurrentPositionTilt::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPositionTilt);
+ case Attributes::NumberOfActuationsLift::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfActuationsLift);
+ case Attributes::NumberOfActuationsTilt::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfActuationsTilt);
+ case Attributes::ConfigStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, configStatus);
+ case Attributes::CurrentPositionLiftPercentage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPositionLiftPercentage);
+ case Attributes::CurrentPositionTiltPercentage::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPositionTiltPercentage);
+ case Attributes::OperationalStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationalStatus);
+ case Attributes::TargetPositionLiftPercent100ths::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, targetPositionLiftPercent100ths);
+ case Attributes::TargetPositionTiltPercent100ths::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, targetPositionTiltPercent100ths);
+ case Attributes::EndProductType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, endProductType);
+ case Attributes::CurrentPositionLiftPercent100ths::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPositionLiftPercent100ths);
+ case Attributes::CurrentPositionTiltPercent100ths::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentPositionTiltPercent100ths);
+ case Attributes::InstalledOpenLimitLift::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, installedOpenLimitLift);
+ case Attributes::InstalledClosedLimitLift::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, installedClosedLimitLift);
+ case Attributes::InstalledOpenLimitTilt::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, installedOpenLimitTilt);
+ case Attributes::InstalledClosedLimitTilt::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, installedClosedLimitTilt);
+ case Attributes::Mode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, mode);
+ case Attributes::SafetyStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, safetyStatus);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace WindowCovering
+namespace ServiceArea {
+namespace Structs {
+
+namespace LandmarkInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLandmarkTag), landmarkTag);
+ encoder.Encode(to_underlying(Fields::kRelativePositionTag), relativePositionTag);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLandmarkTag))
+ {
+ err = DataModel::Decode(reader, landmarkTag);
+ }
+ else if (__context_tag == to_underlying(Fields::kRelativePositionTag))
+ {
+ err = DataModel::Decode(reader, relativePositionTag);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LandmarkInfoStruct
+
+namespace AreaInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLocationInfo), locationInfo);
+ encoder.Encode(to_underlying(Fields::kLandmarkInfo), landmarkInfo);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLocationInfo))
+ {
+ err = DataModel::Decode(reader, locationInfo);
+ }
+ else if (__context_tag == to_underlying(Fields::kLandmarkInfo))
+ {
+ err = DataModel::Decode(reader, landmarkInfo);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AreaInfoStruct
+
+namespace AreaStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAreaID), areaID);
+ encoder.Encode(to_underlying(Fields::kMapID), mapID);
+ encoder.Encode(to_underlying(Fields::kAreaInfo), areaInfo);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAreaID))
+ {
+ err = DataModel::Decode(reader, areaID);
+ }
+ else if (__context_tag == to_underlying(Fields::kMapID))
+ {
+ err = DataModel::Decode(reader, mapID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAreaInfo))
+ {
+ err = DataModel::Decode(reader, areaInfo);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AreaStruct
+
+namespace MapStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMapID), mapID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMapID))
+ {
+ err = DataModel::Decode(reader, mapID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MapStruct
+
+namespace ProgressStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAreaID), areaID);
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kTotalOperationalTime), totalOperationalTime);
+ encoder.Encode(to_underlying(Fields::kEstimatedTime), estimatedTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAreaID))
+ {
+ err = DataModel::Decode(reader, areaID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
+ {
+ err = DataModel::Decode(reader, totalOperationalTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEstimatedTime))
+ {
+ err = DataModel::Decode(reader, estimatedTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProgressStruct
+} // namespace Structs
+
+namespace Commands {
+namespace SelectAreas {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNewAreas), newAreas);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNewAreas))
+ {
+ err = DataModel::Decode(reader, newAreas);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SelectAreas.
+namespace SelectAreasResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SelectAreasResponse.
+namespace SkipArea {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSkippedArea), skippedArea);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSkippedArea))
+ {
+ err = DataModel::Decode(reader, skippedArea);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SkipArea.
+namespace SkipAreaResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kStatusText), statusText);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusText))
+ {
+ err = DataModel::Decode(reader, statusText);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SkipAreaResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedAreas::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedAreas);
+ case Attributes::SupportedMaps::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedMaps);
+ case Attributes::SelectedAreas::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, selectedAreas);
+ case Attributes::CurrentArea::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentArea);
+ case Attributes::EstimatedEndTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, estimatedEndTime);
+ case Attributes::Progress::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, progress);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ServiceArea
+namespace PumpConfigurationAndControl {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MaxPressure::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxPressure);
+ case Attributes::MaxSpeed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxSpeed);
+ case Attributes::MaxFlow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxFlow);
+ case Attributes::MinConstPressure::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minConstPressure);
+ case Attributes::MaxConstPressure::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxConstPressure);
+ case Attributes::MinCompPressure::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minCompPressure);
+ case Attributes::MaxCompPressure::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxCompPressure);
+ case Attributes::MinConstSpeed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minConstSpeed);
+ case Attributes::MaxConstSpeed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxConstSpeed);
+ case Attributes::MinConstFlow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minConstFlow);
+ case Attributes::MaxConstFlow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxConstFlow);
+ case Attributes::MinConstTemp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minConstTemp);
+ case Attributes::MaxConstTemp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxConstTemp);
+ case Attributes::PumpStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, pumpStatus);
+ case Attributes::EffectiveOperationMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, effectiveOperationMode);
+ case Attributes::EffectiveControlMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, effectiveControlMode);
+ case Attributes::Capacity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, capacity);
+ case Attributes::Speed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speed);
+ case Attributes::LifetimeRunningHours::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lifetimeRunningHours);
+ case Attributes::Power::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, power);
+ case Attributes::LifetimeEnergyConsumed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lifetimeEnergyConsumed);
+ case Attributes::OperationMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, operationMode);
+ case Attributes::ControlMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, controlMode);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace SupplyVoltageLow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SupplyVoltageLow.
+namespace SupplyVoltageHigh {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SupplyVoltageHigh.
+namespace PowerMissingPhase {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace PowerMissingPhase.
+namespace SystemPressureLow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SystemPressureLow.
+namespace SystemPressureHigh {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SystemPressureHigh.
+namespace DryRunning {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace DryRunning.
+namespace MotorTemperatureHigh {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace MotorTemperatureHigh.
+namespace PumpMotorFatalFailure {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace PumpMotorFatalFailure.
+namespace ElectronicTemperatureHigh {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ElectronicTemperatureHigh.
+namespace PumpBlocked {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace PumpBlocked.
+namespace SensorFailure {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace SensorFailure.
+namespace ElectronicNonFatalFailure {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ElectronicNonFatalFailure.
+namespace ElectronicFatalFailure {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ElectronicFatalFailure.
+namespace GeneralFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace GeneralFault.
+namespace Leakage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Leakage.
+namespace AirDetection {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace AirDetection.
+namespace TurbineOperation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TurbineOperation.
+} // namespace Events
+
+} // namespace PumpConfigurationAndControl
+namespace Thermostat {
+namespace Structs {
+
+namespace ScheduleTransitionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDayOfWeek), dayOfWeek);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
+ encoder.Encode(to_underlying(Fields::kSystemMode), systemMode);
+ encoder.Encode(to_underlying(Fields::kCoolingSetpoint), coolingSetpoint);
+ encoder.Encode(to_underlying(Fields::kHeatingSetpoint), heatingSetpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDayOfWeek))
+ {
+ err = DataModel::Decode(reader, dayOfWeek);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kPresetHandle))
+ {
+ err = DataModel::Decode(reader, presetHandle);
+ }
+ else if (__context_tag == to_underlying(Fields::kSystemMode))
+ {
+ err = DataModel::Decode(reader, systemMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kCoolingSetpoint))
+ {
+ err = DataModel::Decode(reader, coolingSetpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatingSetpoint))
+ {
+ err = DataModel::Decode(reader, heatingSetpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ScheduleTransitionStruct
+
+namespace ScheduleStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kScheduleHandle), scheduleHandle);
+ encoder.Encode(to_underlying(Fields::kSystemMode), systemMode);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
+ encoder.Encode(to_underlying(Fields::kTransitions), transitions);
+ encoder.Encode(to_underlying(Fields::kBuiltIn), builtIn);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kScheduleHandle))
+ {
+ err = DataModel::Decode(reader, scheduleHandle);
+ }
+ else if (__context_tag == to_underlying(Fields::kSystemMode))
+ {
+ err = DataModel::Decode(reader, systemMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kPresetHandle))
+ {
+ err = DataModel::Decode(reader, presetHandle);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitions))
+ {
+ err = DataModel::Decode(reader, transitions);
+ }
+ else if (__context_tag == to_underlying(Fields::kBuiltIn))
+ {
+ err = DataModel::Decode(reader, builtIn);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ScheduleStruct
+
+namespace PresetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
+ encoder.Encode(to_underlying(Fields::kPresetScenario), presetScenario);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kCoolingSetpoint), coolingSetpoint);
+ encoder.Encode(to_underlying(Fields::kHeatingSetpoint), heatingSetpoint);
+ encoder.Encode(to_underlying(Fields::kBuiltIn), builtIn);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetHandle))
+ {
+ err = DataModel::Decode(reader, presetHandle);
+ }
+ else if (__context_tag == to_underlying(Fields::kPresetScenario))
+ {
+ err = DataModel::Decode(reader, presetScenario);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kCoolingSetpoint))
+ {
+ err = DataModel::Decode(reader, coolingSetpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatingSetpoint))
+ {
+ err = DataModel::Decode(reader, heatingSetpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kBuiltIn))
+ {
+ err = DataModel::Decode(reader, builtIn);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PresetStruct
+
+namespace PresetTypeStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetScenario), presetScenario);
+ encoder.Encode(to_underlying(Fields::kNumberOfPresets), numberOfPresets);
+ encoder.Encode(to_underlying(Fields::kPresetTypeFeatures), presetTypeFeatures);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetScenario))
+ {
+ err = DataModel::Decode(reader, presetScenario);
+ }
+ else if (__context_tag == to_underlying(Fields::kNumberOfPresets))
+ {
+ err = DataModel::Decode(reader, numberOfPresets);
+ }
+ else if (__context_tag == to_underlying(Fields::kPresetTypeFeatures))
+ {
+ err = DataModel::Decode(reader, presetTypeFeatures);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PresetTypeStruct
+
+namespace ScheduleTypeStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSystemMode), systemMode);
+ encoder.Encode(to_underlying(Fields::kNumberOfSchedules), numberOfSchedules);
+ encoder.Encode(to_underlying(Fields::kScheduleTypeFeatures), scheduleTypeFeatures);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSystemMode))
+ {
+ err = DataModel::Decode(reader, systemMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kNumberOfSchedules))
+ {
+ err = DataModel::Decode(reader, numberOfSchedules);
+ }
+ else if (__context_tag == to_underlying(Fields::kScheduleTypeFeatures))
+ {
+ err = DataModel::Decode(reader, scheduleTypeFeatures);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ScheduleTypeStruct
+
+namespace WeeklyScheduleTransitionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kHeatSetpoint), heatSetpoint);
+ encoder.Encode(to_underlying(Fields::kCoolSetpoint), coolSetpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeatSetpoint))
+ {
+ err = DataModel::Decode(reader, heatSetpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kCoolSetpoint))
+ {
+ err = DataModel::Decode(reader, coolSetpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace WeeklyScheduleTransitionStruct
+} // namespace Structs
+
+namespace Commands {
+namespace SetpointRaiseLower {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMode), mode);
+ encoder.Encode(to_underlying(Fields::kAmount), amount);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMode))
+ {
+ err = DataModel::Decode(reader, mode);
+ }
+ else if (__context_tag == to_underlying(Fields::kAmount))
+ {
+ err = DataModel::Decode(reader, amount);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetpointRaiseLower.
+namespace GetWeeklyScheduleResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNumberOfTransitionsForSequence), numberOfTransitionsForSequence);
+ encoder.Encode(to_underlying(Fields::kDayOfWeekForSequence), dayOfWeekForSequence);
+ encoder.Encode(to_underlying(Fields::kModeForSequence), modeForSequence);
+ encoder.Encode(to_underlying(Fields::kTransitions), transitions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNumberOfTransitionsForSequence))
+ {
+ err = DataModel::Decode(reader, numberOfTransitionsForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kDayOfWeekForSequence))
+ {
+ err = DataModel::Decode(reader, dayOfWeekForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kModeForSequence))
+ {
+ err = DataModel::Decode(reader, modeForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitions))
+ {
+ err = DataModel::Decode(reader, transitions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetWeeklyScheduleResponse.
+namespace SetWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNumberOfTransitionsForSequence), numberOfTransitionsForSequence);
+ encoder.Encode(to_underlying(Fields::kDayOfWeekForSequence), dayOfWeekForSequence);
+ encoder.Encode(to_underlying(Fields::kModeForSequence), modeForSequence);
+ encoder.Encode(to_underlying(Fields::kTransitions), transitions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNumberOfTransitionsForSequence))
+ {
+ err = DataModel::Decode(reader, numberOfTransitionsForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kDayOfWeekForSequence))
+ {
+ err = DataModel::Decode(reader, dayOfWeekForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kModeForSequence))
+ {
+ err = DataModel::Decode(reader, modeForSequence);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitions))
+ {
+ err = DataModel::Decode(reader, transitions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetWeeklySchedule.
+namespace GetWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDaysToReturn), daysToReturn);
+ encoder.Encode(to_underlying(Fields::kModeToReturn), modeToReturn);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDaysToReturn))
+ {
+ err = DataModel::Decode(reader, daysToReturn);
+ }
+ else if (__context_tag == to_underlying(Fields::kModeToReturn))
+ {
+ err = DataModel::Decode(reader, modeToReturn);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetWeeklySchedule.
+namespace ClearWeeklySchedule {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ClearWeeklySchedule.
+namespace SetActiveScheduleRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kScheduleHandle), scheduleHandle);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kScheduleHandle))
+ {
+ err = DataModel::Decode(reader, scheduleHandle);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetActiveScheduleRequest.
+namespace SetActivePresetRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetHandle))
+ {
+ err = DataModel::Decode(reader, presetHandle);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetActivePresetRequest.
+namespace AtomicResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatusCode), statusCode);
+ encoder.Encode(to_underlying(Fields::kAttributeStatus), attributeStatus);
+ encoder.Encode(to_underlying(Fields::kTimeout), timeout);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatusCode))
+ {
+ err = DataModel::Decode(reader, statusCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kAttributeStatus))
+ {
+ err = DataModel::Decode(reader, attributeStatus);
+ }
+ else if (__context_tag == to_underlying(Fields::kTimeout))
+ {
+ err = DataModel::Decode(reader, timeout);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AtomicResponse.
+namespace AtomicRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRequestType), requestType);
+ encoder.Encode(to_underlying(Fields::kAttributeRequests), attributeRequests);
+ encoder.Encode(to_underlying(Fields::kTimeout), timeout);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRequestType))
+ {
+ err = DataModel::Decode(reader, requestType);
+ }
+ else if (__context_tag == to_underlying(Fields::kAttributeRequests))
+ {
+ err = DataModel::Decode(reader, attributeRequests);
+ }
+ else if (__context_tag == to_underlying(Fields::kTimeout))
+ {
+ err = DataModel::Decode(reader, timeout);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AtomicRequest.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::LocalTemperature::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localTemperature);
+ case Attributes::OutdoorTemperature::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, outdoorTemperature);
+ case Attributes::Occupancy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupancy);
+ case Attributes::AbsMinHeatSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, absMinHeatSetpointLimit);
+ case Attributes::AbsMaxHeatSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, absMaxHeatSetpointLimit);
+ case Attributes::AbsMinCoolSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, absMinCoolSetpointLimit);
+ case Attributes::AbsMaxCoolSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, absMaxCoolSetpointLimit);
+ case Attributes::PICoolingDemand::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, PICoolingDemand);
+ case Attributes::PIHeatingDemand::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, PIHeatingDemand);
+ case Attributes::HVACSystemTypeConfiguration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, HVACSystemTypeConfiguration);
+ case Attributes::LocalTemperatureCalibration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localTemperatureCalibration);
+ case Attributes::OccupiedCoolingSetpoint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupiedCoolingSetpoint);
+ case Attributes::OccupiedHeatingSetpoint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupiedHeatingSetpoint);
+ case Attributes::UnoccupiedCoolingSetpoint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, unoccupiedCoolingSetpoint);
+ case Attributes::UnoccupiedHeatingSetpoint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, unoccupiedHeatingSetpoint);
+ case Attributes::MinHeatSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minHeatSetpointLimit);
+ case Attributes::MaxHeatSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxHeatSetpointLimit);
+ case Attributes::MinCoolSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minCoolSetpointLimit);
+ case Attributes::MaxCoolSetpointLimit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxCoolSetpointLimit);
+ case Attributes::MinSetpointDeadBand::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minSetpointDeadBand);
+ case Attributes::RemoteSensing::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, remoteSensing);
+ case Attributes::ControlSequenceOfOperation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, controlSequenceOfOperation);
+ case Attributes::SystemMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, systemMode);
+ case Attributes::ThermostatRunningMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, thermostatRunningMode);
+ case Attributes::StartOfWeek::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startOfWeek);
+ case Attributes::NumberOfWeeklyTransitions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfWeeklyTransitions);
+ case Attributes::NumberOfDailyTransitions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfDailyTransitions);
+ case Attributes::TemperatureSetpointHold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, temperatureSetpointHold);
+ case Attributes::TemperatureSetpointHoldDuration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, temperatureSetpointHoldDuration);
+ case Attributes::ThermostatProgrammingOperationMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, thermostatProgrammingOperationMode);
+ case Attributes::ThermostatRunningState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, thermostatRunningState);
+ case Attributes::SetpointChangeSource::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, setpointChangeSource);
+ case Attributes::SetpointChangeAmount::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, setpointChangeAmount);
+ case Attributes::SetpointChangeSourceTimestamp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, setpointChangeSourceTimestamp);
+ case Attributes::OccupiedSetback::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupiedSetback);
+ case Attributes::OccupiedSetbackMin::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupiedSetbackMin);
+ case Attributes::OccupiedSetbackMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupiedSetbackMax);
+ case Attributes::UnoccupiedSetback::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, unoccupiedSetback);
+ case Attributes::UnoccupiedSetbackMin::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, unoccupiedSetbackMin);
+ case Attributes::UnoccupiedSetbackMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, unoccupiedSetbackMax);
+ case Attributes::EmergencyHeatDelta::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, emergencyHeatDelta);
+ case Attributes::ACType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACType);
+ case Attributes::ACCapacity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACCapacity);
+ case Attributes::ACRefrigerantType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACRefrigerantType);
+ case Attributes::ACCompressorType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACCompressorType);
+ case Attributes::ACErrorCode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACErrorCode);
+ case Attributes::ACLouverPosition::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACLouverPosition);
+ case Attributes::ACCoilTemperature::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACCoilTemperature);
+ case Attributes::ACCapacityformat::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ACCapacityformat);
+ case Attributes::PresetTypes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, presetTypes);
+ case Attributes::ScheduleTypes::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scheduleTypes);
+ case Attributes::NumberOfPresets::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfPresets);
+ case Attributes::NumberOfSchedules::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfSchedules);
+ case Attributes::NumberOfScheduleTransitions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfScheduleTransitions);
+ case Attributes::NumberOfScheduleTransitionPerDay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfScheduleTransitionPerDay);
+ case Attributes::ActivePresetHandle::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activePresetHandle);
+ case Attributes::ActiveScheduleHandle::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeScheduleHandle);
+ case Attributes::Presets::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, presets);
+ case Attributes::Schedules::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, schedules);
+ case Attributes::SetpointHoldExpiryTimestamp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, setpointHoldExpiryTimestamp);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Thermostat
+namespace FanControl {
+
+namespace Commands {
+namespace Step {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDirection), direction);
+ encoder.Encode(to_underlying(Fields::kWrap), wrap);
+ encoder.Encode(to_underlying(Fields::kLowestOff), lowestOff);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDirection))
+ {
+ err = DataModel::Decode(reader, direction);
+ }
+ else if (__context_tag == to_underlying(Fields::kWrap))
+ {
+ err = DataModel::Decode(reader, wrap);
+ }
+ else if (__context_tag == to_underlying(Fields::kLowestOff))
+ {
+ err = DataModel::Decode(reader, lowestOff);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Step.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::FanMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, fanMode);
+ case Attributes::FanModeSequence::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, fanModeSequence);
+ case Attributes::PercentSetting::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, percentSetting);
+ case Attributes::PercentCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, percentCurrent);
+ case Attributes::SpeedMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speedMax);
+ case Attributes::SpeedSetting::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speedSetting);
+ case Attributes::SpeedCurrent::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speedCurrent);
+ case Attributes::RockSupport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rockSupport);
+ case Attributes::RockSetting::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rockSetting);
+ case Attributes::WindSupport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, windSupport);
+ case Attributes::WindSetting::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, windSetting);
+ case Attributes::AirflowDirection::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, airflowDirection);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace FanControl
+namespace ThermostatUserInterfaceConfiguration {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::TemperatureDisplayMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, temperatureDisplayMode);
+ case Attributes::KeypadLockout::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, keypadLockout);
+ case Attributes::ScheduleProgrammingVisibility::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scheduleProgrammingVisibility);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ThermostatUserInterfaceConfiguration
+namespace ColorControl {
+
+namespace Commands {
+namespace MoveToHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHue), hue);
+ encoder.Encode(to_underlying(Fields::kDirection), direction);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHue))
+ {
+ err = DataModel::Decode(reader, hue);
+ }
+ else if (__context_tag == to_underlying(Fields::kDirection))
+ {
+ err = DataModel::Decode(reader, direction);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToHue.
+namespace MoveHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
+ encoder.Encode(to_underlying(Fields::kRate), rate);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMoveMode))
+ {
+ err = DataModel::Decode(reader, moveMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kRate))
+ {
+ err = DataModel::Decode(reader, rate);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveHue.
+namespace StepHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
+ encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepMode))
+ {
+ err = DataModel::Decode(reader, stepMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepSize))
+ {
+ err = DataModel::Decode(reader, stepSize);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StepHue.
+namespace MoveToSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSaturation), saturation);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSaturation))
+ {
+ err = DataModel::Decode(reader, saturation);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToSaturation.
+namespace MoveSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
+ encoder.Encode(to_underlying(Fields::kRate), rate);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMoveMode))
+ {
+ err = DataModel::Decode(reader, moveMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kRate))
+ {
+ err = DataModel::Decode(reader, rate);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveSaturation.
+namespace StepSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
+ encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepMode))
+ {
+ err = DataModel::Decode(reader, stepMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepSize))
+ {
+ err = DataModel::Decode(reader, stepSize);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StepSaturation.
+namespace MoveToHueAndSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHue), hue);
+ encoder.Encode(to_underlying(Fields::kSaturation), saturation);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHue))
+ {
+ err = DataModel::Decode(reader, hue);
+ }
+ else if (__context_tag == to_underlying(Fields::kSaturation))
+ {
+ err = DataModel::Decode(reader, saturation);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToHueAndSaturation.
+namespace MoveToColor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kColorX), colorX);
+ encoder.Encode(to_underlying(Fields::kColorY), colorY);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kColorX))
+ {
+ err = DataModel::Decode(reader, colorX);
+ }
+ else if (__context_tag == to_underlying(Fields::kColorY))
+ {
+ err = DataModel::Decode(reader, colorY);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToColor.
+namespace MoveColor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRateX), rateX);
+ encoder.Encode(to_underlying(Fields::kRateY), rateY);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRateX))
+ {
+ err = DataModel::Decode(reader, rateX);
+ }
+ else if (__context_tag == to_underlying(Fields::kRateY))
+ {
+ err = DataModel::Decode(reader, rateY);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveColor.
+namespace StepColor {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepX), stepX);
+ encoder.Encode(to_underlying(Fields::kStepY), stepY);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepX))
+ {
+ err = DataModel::Decode(reader, stepX);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepY))
+ {
+ err = DataModel::Decode(reader, stepY);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StepColor.
+namespace MoveToColorTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kColorTemperatureMireds), colorTemperatureMireds);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kColorTemperatureMireds))
+ {
+ err = DataModel::Decode(reader, colorTemperatureMireds);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveToColorTemperature.
+namespace EnhancedMoveToHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEnhancedHue), enhancedHue);
+ encoder.Encode(to_underlying(Fields::kDirection), direction);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnhancedHue))
+ {
+ err = DataModel::Decode(reader, enhancedHue);
+ }
+ else if (__context_tag == to_underlying(Fields::kDirection))
+ {
+ err = DataModel::Decode(reader, direction);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnhancedMoveToHue.
+namespace EnhancedMoveHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
+ encoder.Encode(to_underlying(Fields::kRate), rate);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMoveMode))
+ {
+ err = DataModel::Decode(reader, moveMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kRate))
+ {
+ err = DataModel::Decode(reader, rate);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnhancedMoveHue.
+namespace EnhancedStepHue {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
+ encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepMode))
+ {
+ err = DataModel::Decode(reader, stepMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepSize))
+ {
+ err = DataModel::Decode(reader, stepSize);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnhancedStepHue.
+namespace EnhancedMoveToHueAndSaturation {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kEnhancedHue), enhancedHue);
+ encoder.Encode(to_underlying(Fields::kSaturation), saturation);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kEnhancedHue))
+ {
+ err = DataModel::Decode(reader, enhancedHue);
+ }
+ else if (__context_tag == to_underlying(Fields::kSaturation))
+ {
+ err = DataModel::Decode(reader, saturation);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EnhancedMoveToHueAndSaturation.
+namespace ColorLoopSet {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUpdateFlags), updateFlags);
+ encoder.Encode(to_underlying(Fields::kAction), action);
+ encoder.Encode(to_underlying(Fields::kDirection), direction);
+ encoder.Encode(to_underlying(Fields::kTime), time);
+ encoder.Encode(to_underlying(Fields::kStartHue), startHue);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUpdateFlags))
+ {
+ err = DataModel::Decode(reader, updateFlags);
+ }
+ else if (__context_tag == to_underlying(Fields::kAction))
+ {
+ err = DataModel::Decode(reader, action);
+ }
+ else if (__context_tag == to_underlying(Fields::kDirection))
+ {
+ err = DataModel::Decode(reader, direction);
+ }
+ else if (__context_tag == to_underlying(Fields::kTime))
+ {
+ err = DataModel::Decode(reader, time);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartHue))
+ {
+ err = DataModel::Decode(reader, startHue);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ColorLoopSet.
+namespace StopMoveStep {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StopMoveStep.
+namespace MoveColorTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
+ encoder.Encode(to_underlying(Fields::kRate), rate);
+ encoder.Encode(to_underlying(Fields::kColorTemperatureMinimumMireds), colorTemperatureMinimumMireds);
+ encoder.Encode(to_underlying(Fields::kColorTemperatureMaximumMireds), colorTemperatureMaximumMireds);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMoveMode))
+ {
+ err = DataModel::Decode(reader, moveMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kRate))
+ {
+ err = DataModel::Decode(reader, rate);
+ }
+ else if (__context_tag == to_underlying(Fields::kColorTemperatureMinimumMireds))
+ {
+ err = DataModel::Decode(reader, colorTemperatureMinimumMireds);
+ }
+ else if (__context_tag == to_underlying(Fields::kColorTemperatureMaximumMireds))
+ {
+ err = DataModel::Decode(reader, colorTemperatureMaximumMireds);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MoveColorTemperature.
+namespace StepColorTemperature {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
+ encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
+ encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
+ encoder.Encode(to_underlying(Fields::kColorTemperatureMinimumMireds), colorTemperatureMinimumMireds);
+ encoder.Encode(to_underlying(Fields::kColorTemperatureMaximumMireds), colorTemperatureMaximumMireds);
+ encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
+ encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStepMode))
+ {
+ err = DataModel::Decode(reader, stepMode);
+ }
+ else if (__context_tag == to_underlying(Fields::kStepSize))
+ {
+ err = DataModel::Decode(reader, stepSize);
+ }
+ else if (__context_tag == to_underlying(Fields::kTransitionTime))
+ {
+ err = DataModel::Decode(reader, transitionTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kColorTemperatureMinimumMireds))
+ {
+ err = DataModel::Decode(reader, colorTemperatureMinimumMireds);
+ }
+ else if (__context_tag == to_underlying(Fields::kColorTemperatureMaximumMireds))
+ {
+ err = DataModel::Decode(reader, colorTemperatureMaximumMireds);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsMask))
+ {
+ err = DataModel::Decode(reader, optionsMask);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionsOverride))
+ {
+ err = DataModel::Decode(reader, optionsOverride);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StepColorTemperature.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CurrentHue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentHue);
+ case Attributes::CurrentSaturation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentSaturation);
+ case Attributes::RemainingTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, remainingTime);
+ case Attributes::CurrentX::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentX);
+ case Attributes::CurrentY::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentY);
+ case Attributes::DriftCompensation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, driftCompensation);
+ case Attributes::CompensationText::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, compensationText);
+ case Attributes::ColorTemperatureMireds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorTemperatureMireds);
+ case Attributes::ColorMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorMode);
+ case Attributes::Options::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, options);
+ case Attributes::NumberOfPrimaries::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, numberOfPrimaries);
+ case Attributes::Primary1X::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary1X);
+ case Attributes::Primary1Y::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary1Y);
+ case Attributes::Primary1Intensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary1Intensity);
+ case Attributes::Primary2X::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary2X);
+ case Attributes::Primary2Y::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary2Y);
+ case Attributes::Primary2Intensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary2Intensity);
+ case Attributes::Primary3X::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary3X);
+ case Attributes::Primary3Y::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary3Y);
+ case Attributes::Primary3Intensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary3Intensity);
+ case Attributes::Primary4X::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary4X);
+ case Attributes::Primary4Y::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary4Y);
+ case Attributes::Primary4Intensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary4Intensity);
+ case Attributes::Primary5X::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary5X);
+ case Attributes::Primary5Y::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary5Y);
+ case Attributes::Primary5Intensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary5Intensity);
+ case Attributes::Primary6X::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary6X);
+ case Attributes::Primary6Y::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary6Y);
+ case Attributes::Primary6Intensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, primary6Intensity);
+ case Attributes::WhitePointX::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, whitePointX);
+ case Attributes::WhitePointY::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, whitePointY);
+ case Attributes::ColorPointRX::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointRX);
+ case Attributes::ColorPointRY::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointRY);
+ case Attributes::ColorPointRIntensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointRIntensity);
+ case Attributes::ColorPointGX::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointGX);
+ case Attributes::ColorPointGY::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointGY);
+ case Attributes::ColorPointGIntensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointGIntensity);
+ case Attributes::ColorPointBX::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointBX);
+ case Attributes::ColorPointBY::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointBY);
+ case Attributes::ColorPointBIntensity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorPointBIntensity);
+ case Attributes::EnhancedCurrentHue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enhancedCurrentHue);
+ case Attributes::EnhancedColorMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enhancedColorMode);
+ case Attributes::ColorLoopActive::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorLoopActive);
+ case Attributes::ColorLoopDirection::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorLoopDirection);
+ case Attributes::ColorLoopTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorLoopTime);
+ case Attributes::ColorLoopStartEnhancedHue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorLoopStartEnhancedHue);
+ case Attributes::ColorLoopStoredEnhancedHue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorLoopStoredEnhancedHue);
+ case Attributes::ColorCapabilities::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorCapabilities);
+ case Attributes::ColorTempPhysicalMinMireds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorTempPhysicalMinMireds);
+ case Attributes::ColorTempPhysicalMaxMireds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, colorTempPhysicalMaxMireds);
+ case Attributes::CoupleColorTempToLevelMinMireds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, coupleColorTempToLevelMinMireds);
+ case Attributes::StartUpColorTemperatureMireds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startUpColorTemperatureMireds);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ColorControl
+namespace BallastConfiguration {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PhysicalMinLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalMinLevel);
+ case Attributes::PhysicalMaxLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalMaxLevel);
+ case Attributes::BallastStatus::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ballastStatus);
+ case Attributes::MinLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minLevel);
+ case Attributes::MaxLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxLevel);
+ case Attributes::IntrinsicBallastFactor::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, intrinsicBallastFactor);
+ case Attributes::BallastFactorAdjustment::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ballastFactorAdjustment);
+ case Attributes::LampQuantity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampQuantity);
+ case Attributes::LampType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampType);
+ case Attributes::LampManufacturer::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampManufacturer);
+ case Attributes::LampRatedHours::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampRatedHours);
+ case Attributes::LampBurnHours::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampBurnHours);
+ case Attributes::LampAlarmMode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampAlarmMode);
+ case Attributes::LampBurnHoursTripPoint::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lampBurnHoursTripPoint);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace BallastConfiguration
+namespace IlluminanceMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::Tolerance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tolerance);
+ case Attributes::LightSensorType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lightSensorType);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace IlluminanceMeasurement
+namespace TemperatureMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::Tolerance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tolerance);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace TemperatureMeasurement
+namespace PressureMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::Tolerance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tolerance);
+ case Attributes::ScaledValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scaledValue);
+ case Attributes::MinScaledValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minScaledValue);
+ case Attributes::MaxScaledValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxScaledValue);
+ case Attributes::ScaledTolerance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scaledTolerance);
+ case Attributes::Scale::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scale);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace PressureMeasurement
+namespace FlowMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::Tolerance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tolerance);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace FlowMeasurement
+namespace RelativeHumidityMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::Tolerance::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tolerance);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace RelativeHumidityMeasurement
+namespace OccupancySensing {
+namespace Structs {
+
+namespace HoldTimeLimitsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kHoldTimeMin), holdTimeMin);
+ encoder.Encode(to_underlying(Fields::kHoldTimeMax), holdTimeMax);
+ encoder.Encode(to_underlying(Fields::kHoldTimeDefault), holdTimeDefault);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kHoldTimeMin))
+ {
+ err = DataModel::Decode(reader, holdTimeMin);
+ }
+ else if (__context_tag == to_underlying(Fields::kHoldTimeMax))
+ {
+ err = DataModel::Decode(reader, holdTimeMax);
+ }
+ else if (__context_tag == to_underlying(Fields::kHoldTimeDefault))
+ {
+ err = DataModel::Decode(reader, holdTimeDefault);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace HoldTimeLimitsStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Occupancy::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupancy);
+ case Attributes::OccupancySensorType::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupancySensorType);
+ case Attributes::OccupancySensorTypeBitmap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, occupancySensorTypeBitmap);
+ case Attributes::HoldTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, holdTime);
+ case Attributes::HoldTimeLimits::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, holdTimeLimits);
+ case Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, PIROccupiedToUnoccupiedDelay);
+ case Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, PIRUnoccupiedToOccupiedDelay);
+ case Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, PIRUnoccupiedToOccupiedThreshold);
+ case Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ultrasonicOccupiedToUnoccupiedDelay);
+ case Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ultrasonicUnoccupiedToOccupiedDelay);
+ case Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ultrasonicUnoccupiedToOccupiedThreshold);
+ case Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalContactOccupiedToUnoccupiedDelay);
+ case Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalContactUnoccupiedToOccupiedDelay);
+ case Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, physicalContactUnoccupiedToOccupiedThreshold);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace OccupancyChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOccupancy), occupancy));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOccupancy))
+ {
+ err = DataModel::Decode(reader, occupancy);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OccupancyChanged.
+} // namespace Events
+
+} // namespace OccupancySensing
+namespace CarbonMonoxideConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace CarbonMonoxideConcentrationMeasurement
+namespace CarbonDioxideConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace CarbonDioxideConcentrationMeasurement
+namespace NitrogenDioxideConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace NitrogenDioxideConcentrationMeasurement
+namespace OzoneConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace OzoneConcentrationMeasurement
+namespace Pm25ConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Pm25ConcentrationMeasurement
+namespace FormaldehydeConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace FormaldehydeConcentrationMeasurement
+namespace Pm1ConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Pm1ConcentrationMeasurement
+namespace Pm10ConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Pm10ConcentrationMeasurement
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+namespace RadonConcentrationMeasurement {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measuredValue);
+ case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minMeasuredValue);
+ case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxMeasuredValue);
+ case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValue);
+ case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, peakMeasuredValueWindow);
+ case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValue);
+ case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, averageMeasuredValueWindow);
+ case Attributes::Uncertainty::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, uncertainty);
+ case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementUnit);
+ case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, measurementMedium);
+ case Attributes::LevelValue::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, levelValue);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace RadonConcentrationMeasurement
+namespace WiFiNetworkManagement {
+
+namespace Commands {
+namespace NetworkPassphraseRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace NetworkPassphraseRequest.
+namespace NetworkPassphraseResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPassphrase), passphrase);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPassphrase))
+ {
+ err = DataModel::Decode(reader, passphrase);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NetworkPassphraseResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Ssid::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, ssid);
+ case Attributes::PassphraseSurrogate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, passphraseSurrogate);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace WiFiNetworkManagement
+namespace ThreadBorderRouterManagement {
+
+namespace Commands {
+namespace GetActiveDatasetRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace GetActiveDatasetRequest.
+namespace GetPendingDatasetRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace GetPendingDatasetRequest.
+namespace DatasetResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDataset), dataset);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDataset))
+ {
+ err = DataModel::Decode(reader, dataset);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DatasetResponse.
+namespace SetActiveDatasetRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kActiveDataset), activeDataset);
+ encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kActiveDataset))
+ {
+ err = DataModel::Decode(reader, activeDataset);
+ }
+ else if (__context_tag == to_underlying(Fields::kBreadcrumb))
+ {
+ err = DataModel::Decode(reader, breadcrumb);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetActiveDatasetRequest.
+namespace SetPendingDatasetRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPendingDataset), pendingDataset);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPendingDataset))
+ {
+ err = DataModel::Decode(reader, pendingDataset);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetPendingDatasetRequest.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::BorderRouterName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, borderRouterName);
+ case Attributes::BorderAgentID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, borderAgentID);
+ case Attributes::ThreadVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, threadVersion);
+ case Attributes::InterfaceEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, interfaceEnabled);
+ case Attributes::ActiveDatasetTimestamp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeDatasetTimestamp);
+ case Attributes::PendingDatasetTimestamp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, pendingDatasetTimestamp);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ThreadBorderRouterManagement
+namespace ThreadNetworkDirectory {
+namespace Structs {
+
+namespace ThreadNetworkStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kExtendedPanID), extendedPanID);
+ encoder.Encode(to_underlying(Fields::kNetworkName), networkName);
+ encoder.Encode(to_underlying(Fields::kChannel), channel);
+ encoder.Encode(to_underlying(Fields::kActiveTimestamp), activeTimestamp);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kExtendedPanID))
+ {
+ err = DataModel::Decode(reader, extendedPanID);
+ }
+ else if (__context_tag == to_underlying(Fields::kNetworkName))
+ {
+ err = DataModel::Decode(reader, networkName);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannel))
+ {
+ err = DataModel::Decode(reader, channel);
+ }
+ else if (__context_tag == to_underlying(Fields::kActiveTimestamp))
+ {
+ err = DataModel::Decode(reader, activeTimestamp);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ThreadNetworkStruct
+} // namespace Structs
+
+namespace Commands {
+namespace AddNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperationalDataset), operationalDataset);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperationalDataset))
+ {
+ err = DataModel::Decode(reader, operationalDataset);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddNetwork.
+namespace RemoveNetwork {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kExtendedPanID), extendedPanID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kExtendedPanID))
+ {
+ err = DataModel::Decode(reader, extendedPanID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveNetwork.
+namespace GetOperationalDataset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kExtendedPanID), extendedPanID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kExtendedPanID))
+ {
+ err = DataModel::Decode(reader, extendedPanID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetOperationalDataset.
+namespace OperationalDatasetResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperationalDataset), operationalDataset);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperationalDataset))
+ {
+ err = DataModel::Decode(reader, operationalDataset);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace OperationalDatasetResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::PreferredExtendedPanID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, preferredExtendedPanID);
+ case Attributes::ThreadNetworks::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, threadNetworks);
+ case Attributes::ThreadNetworkTableSize::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, threadNetworkTableSize);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ThreadNetworkDirectory
+namespace WakeOnLan {
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MACAddress::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, MACAddress);
+ case Attributes::LinkLocalAddress::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, linkLocalAddress);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace WakeOnLan
+namespace Channel {
+namespace Structs {
+
+namespace ProgramCastStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kRole), role);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kRole))
+ {
+ err = DataModel::Decode(reader, role);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProgramCastStruct
+
+namespace ProgramCategoryStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCategory), category);
+ encoder.Encode(to_underlying(Fields::kSubCategory), subCategory);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCategory))
+ {
+ err = DataModel::Decode(reader, category);
+ }
+ else if (__context_tag == to_underlying(Fields::kSubCategory))
+ {
+ err = DataModel::Decode(reader, subCategory);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProgramCategoryStruct
+
+namespace SeriesInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSeason), season);
+ encoder.Encode(to_underlying(Fields::kEpisode), episode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSeason))
+ {
+ err = DataModel::Decode(reader, season);
+ }
+ else if (__context_tag == to_underlying(Fields::kEpisode))
+ {
+ err = DataModel::Decode(reader, episode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SeriesInfoStruct
+
+namespace ChannelInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMajorNumber), majorNumber);
+ encoder.Encode(to_underlying(Fields::kMinorNumber), minorNumber);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kCallSign), callSign);
+ encoder.Encode(to_underlying(Fields::kAffiliateCallSign), affiliateCallSign);
+ encoder.Encode(to_underlying(Fields::kIdentifier), identifier);
+ encoder.Encode(to_underlying(Fields::kType), type);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMajorNumber))
+ {
+ err = DataModel::Decode(reader, majorNumber);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinorNumber))
+ {
+ err = DataModel::Decode(reader, minorNumber);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kCallSign))
+ {
+ err = DataModel::Decode(reader, callSign);
+ }
+ else if (__context_tag == to_underlying(Fields::kAffiliateCallSign))
+ {
+ err = DataModel::Decode(reader, affiliateCallSign);
+ }
+ else if (__context_tag == to_underlying(Fields::kIdentifier))
+ {
+ err = DataModel::Decode(reader, identifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ChannelInfoStruct
+
+namespace ProgramStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIdentifier), identifier);
+ encoder.Encode(to_underlying(Fields::kChannel), channel);
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kEndTime), endTime);
+ encoder.Encode(to_underlying(Fields::kTitle), title);
+ encoder.Encode(to_underlying(Fields::kSubtitle), subtitle);
+ encoder.Encode(to_underlying(Fields::kDescription), description);
+ encoder.Encode(to_underlying(Fields::kAudioLanguages), audioLanguages);
+ encoder.Encode(to_underlying(Fields::kRatings), ratings);
+ encoder.Encode(to_underlying(Fields::kThumbnailUrl), thumbnailUrl);
+ encoder.Encode(to_underlying(Fields::kPosterArtUrl), posterArtUrl);
+ encoder.Encode(to_underlying(Fields::kDvbiUrl), dvbiUrl);
+ encoder.Encode(to_underlying(Fields::kReleaseDate), releaseDate);
+ encoder.Encode(to_underlying(Fields::kParentalGuidanceText), parentalGuidanceText);
+ encoder.Encode(to_underlying(Fields::kRecordingFlag), recordingFlag);
+ encoder.Encode(to_underlying(Fields::kSeriesInfo), seriesInfo);
+ encoder.Encode(to_underlying(Fields::kCategoryList), categoryList);
+ encoder.Encode(to_underlying(Fields::kCastList), castList);
+ encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIdentifier))
+ {
+ err = DataModel::Decode(reader, identifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannel))
+ {
+ err = DataModel::Decode(reader, channel);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndTime))
+ {
+ err = DataModel::Decode(reader, endTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kTitle))
+ {
+ err = DataModel::Decode(reader, title);
+ }
+ else if (__context_tag == to_underlying(Fields::kSubtitle))
+ {
+ err = DataModel::Decode(reader, subtitle);
+ }
+ else if (__context_tag == to_underlying(Fields::kDescription))
+ {
+ err = DataModel::Decode(reader, description);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioLanguages))
+ {
+ err = DataModel::Decode(reader, audioLanguages);
+ }
+ else if (__context_tag == to_underlying(Fields::kRatings))
+ {
+ err = DataModel::Decode(reader, ratings);
+ }
+ else if (__context_tag == to_underlying(Fields::kThumbnailUrl))
+ {
+ err = DataModel::Decode(reader, thumbnailUrl);
+ }
+ else if (__context_tag == to_underlying(Fields::kPosterArtUrl))
+ {
+ err = DataModel::Decode(reader, posterArtUrl);
+ }
+ else if (__context_tag == to_underlying(Fields::kDvbiUrl))
+ {
+ err = DataModel::Decode(reader, dvbiUrl);
+ }
+ else if (__context_tag == to_underlying(Fields::kReleaseDate))
+ {
+ err = DataModel::Decode(reader, releaseDate);
+ }
+ else if (__context_tag == to_underlying(Fields::kParentalGuidanceText))
+ {
+ err = DataModel::Decode(reader, parentalGuidanceText);
+ }
+ else if (__context_tag == to_underlying(Fields::kRecordingFlag))
+ {
+ err = DataModel::Decode(reader, recordingFlag);
+ }
+ else if (__context_tag == to_underlying(Fields::kSeriesInfo))
+ {
+ err = DataModel::Decode(reader, seriesInfo);
+ }
+ else if (__context_tag == to_underlying(Fields::kCategoryList))
+ {
+ err = DataModel::Decode(reader, categoryList);
+ }
+ else if (__context_tag == to_underlying(Fields::kCastList))
+ {
+ err = DataModel::Decode(reader, castList);
+ }
+ else if (__context_tag == to_underlying(Fields::kExternalIDList))
+ {
+ err = DataModel::Decode(reader, externalIDList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ProgramStruct
+
+namespace PageTokenStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLimit), limit);
+ encoder.Encode(to_underlying(Fields::kAfter), after);
+ encoder.Encode(to_underlying(Fields::kBefore), before);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLimit))
+ {
+ err = DataModel::Decode(reader, limit);
+ }
+ else if (__context_tag == to_underlying(Fields::kAfter))
+ {
+ err = DataModel::Decode(reader, after);
+ }
+ else if (__context_tag == to_underlying(Fields::kBefore))
+ {
+ err = DataModel::Decode(reader, before);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PageTokenStruct
+
+namespace ChannelPagingStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPreviousToken), previousToken);
+ encoder.Encode(to_underlying(Fields::kNextToken), nextToken);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPreviousToken))
+ {
+ err = DataModel::Decode(reader, previousToken);
+ }
+ else if (__context_tag == to_underlying(Fields::kNextToken))
+ {
+ err = DataModel::Decode(reader, nextToken);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ChannelPagingStruct
+
+namespace AdditionalInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AdditionalInfoStruct
+
+namespace LineupInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOperatorName), operatorName);
+ encoder.Encode(to_underlying(Fields::kLineupName), lineupName);
+ encoder.Encode(to_underlying(Fields::kPostalCode), postalCode);
+ encoder.Encode(to_underlying(Fields::kLineupInfoType), lineupInfoType);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOperatorName))
+ {
+ err = DataModel::Decode(reader, operatorName);
+ }
+ else if (__context_tag == to_underlying(Fields::kLineupName))
+ {
+ err = DataModel::Decode(reader, lineupName);
+ }
+ else if (__context_tag == to_underlying(Fields::kPostalCode))
+ {
+ err = DataModel::Decode(reader, postalCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kLineupInfoType))
+ {
+ err = DataModel::Decode(reader, lineupInfoType);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace LineupInfoStruct
+} // namespace Structs
+
+namespace Commands {
+namespace ChangeChannel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMatch), match);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMatch))
+ {
+ err = DataModel::Decode(reader, match);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeChannel.
+namespace ChangeChannelResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeChannelResponse.
+namespace ChangeChannelByNumber {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMajorNumber), majorNumber);
+ encoder.Encode(to_underlying(Fields::kMinorNumber), minorNumber);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMajorNumber))
+ {
+ err = DataModel::Decode(reader, majorNumber);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinorNumber))
+ {
+ err = DataModel::Decode(reader, minorNumber);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ChangeChannelByNumber.
+namespace SkipChannel {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCount), count);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCount))
+ {
+ err = DataModel::Decode(reader, count);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SkipChannel.
+namespace GetProgramGuide {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStartTime), startTime);
+ encoder.Encode(to_underlying(Fields::kEndTime), endTime);
+ encoder.Encode(to_underlying(Fields::kChannelList), channelList);
+ encoder.Encode(to_underlying(Fields::kPageToken), pageToken);
+ encoder.Encode(to_underlying(Fields::kRecordingFlag), recordingFlag);
+ encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndTime))
+ {
+ err = DataModel::Decode(reader, endTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannelList))
+ {
+ err = DataModel::Decode(reader, channelList);
+ }
+ else if (__context_tag == to_underlying(Fields::kPageToken))
+ {
+ err = DataModel::Decode(reader, pageToken);
+ }
+ else if (__context_tag == to_underlying(Fields::kRecordingFlag))
+ {
+ err = DataModel::Decode(reader, recordingFlag);
+ }
+ else if (__context_tag == to_underlying(Fields::kExternalIDList))
+ {
+ err = DataModel::Decode(reader, externalIDList);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetProgramGuide.
+namespace ProgramGuideResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPaging), paging);
+ encoder.Encode(to_underlying(Fields::kProgramList), programList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPaging))
+ {
+ err = DataModel::Decode(reader, paging);
+ }
+ else if (__context_tag == to_underlying(Fields::kProgramList))
+ {
+ err = DataModel::Decode(reader, programList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ProgramGuideResponse.
+namespace RecordProgram {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProgramIdentifier), programIdentifier);
+ encoder.Encode(to_underlying(Fields::kShouldRecordSeries), shouldRecordSeries);
+ encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProgramIdentifier))
+ {
+ err = DataModel::Decode(reader, programIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kShouldRecordSeries))
+ {
+ err = DataModel::Decode(reader, shouldRecordSeries);
+ }
+ else if (__context_tag == to_underlying(Fields::kExternalIDList))
+ {
+ err = DataModel::Decode(reader, externalIDList);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RecordProgram.
+namespace CancelRecordProgram {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProgramIdentifier), programIdentifier);
+ encoder.Encode(to_underlying(Fields::kShouldRecordSeries), shouldRecordSeries);
+ encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProgramIdentifier))
+ {
+ err = DataModel::Decode(reader, programIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kShouldRecordSeries))
+ {
+ err = DataModel::Decode(reader, shouldRecordSeries);
+ }
+ else if (__context_tag == to_underlying(Fields::kExternalIDList))
+ {
+ err = DataModel::Decode(reader, externalIDList);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CancelRecordProgram.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::ChannelList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, channelList);
+ case Attributes::Lineup::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, lineup);
+ case Attributes::CurrentChannel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentChannel);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Channel
+namespace TargetNavigator {
+namespace Structs {
+
+namespace TargetInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIdentifier), identifier);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIdentifier))
+ {
+ err = DataModel::Decode(reader, identifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TargetInfoStruct
+} // namespace Structs
+
+namespace Commands {
+namespace NavigateTarget {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTarget), target);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTarget))
+ {
+ err = DataModel::Decode(reader, target);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NavigateTarget.
+namespace NavigateTargetResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace NavigateTargetResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::TargetList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, targetList);
+ case Attributes::CurrentTarget::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentTarget);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace TargetUpdated {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTargetList), targetList));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentTarget), currentTarget));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kData), data));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTargetList))
+ {
+ err = DataModel::Decode(reader, targetList);
+ }
+ else if (__context_tag == to_underlying(Fields::kCurrentTarget))
+ {
+ err = DataModel::Decode(reader, currentTarget);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TargetUpdated.
+} // namespace Events
+
+} // namespace TargetNavigator
+namespace MediaPlayback {
+namespace Structs {
+
+namespace TrackAttributesStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLanguageCode), languageCode);
+ encoder.Encode(to_underlying(Fields::kDisplayName), displayName);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLanguageCode))
+ {
+ err = DataModel::Decode(reader, languageCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kDisplayName))
+ {
+ err = DataModel::Decode(reader, displayName);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TrackAttributesStruct
+
+namespace TrackStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kId), id);
+ encoder.Encode(to_underlying(Fields::kTrackAttributes), trackAttributes);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else if (__context_tag == to_underlying(Fields::kTrackAttributes))
+ {
+ err = DataModel::Decode(reader, trackAttributes);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TrackStruct
+
+namespace PlaybackPositionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kUpdatedAt), updatedAt);
+ encoder.Encode(to_underlying(Fields::kPosition), position);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUpdatedAt))
+ {
+ err = DataModel::Decode(reader, updatedAt);
+ }
+ else if (__context_tag == to_underlying(Fields::kPosition))
+ {
+ err = DataModel::Decode(reader, position);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PlaybackPositionStruct
+} // namespace Structs
+
+namespace Commands {
+namespace Play {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Play.
+namespace Pause {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Pause.
+namespace Stop {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Stop.
+namespace StartOver {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace StartOver.
+namespace Previous {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Previous.
+namespace Next {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Next.
+namespace Rewind {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAudioAdvanceUnmuted), audioAdvanceUnmuted);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAudioAdvanceUnmuted))
+ {
+ err = DataModel::Decode(reader, audioAdvanceUnmuted);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Rewind.
+namespace FastForward {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAudioAdvanceUnmuted), audioAdvanceUnmuted);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAudioAdvanceUnmuted))
+ {
+ err = DataModel::Decode(reader, audioAdvanceUnmuted);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace FastForward.
+namespace SkipForward {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDeltaPositionMilliseconds), deltaPositionMilliseconds);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDeltaPositionMilliseconds))
+ {
+ err = DataModel::Decode(reader, deltaPositionMilliseconds);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SkipForward.
+namespace SkipBackward {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kDeltaPositionMilliseconds), deltaPositionMilliseconds);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDeltaPositionMilliseconds))
+ {
+ err = DataModel::Decode(reader, deltaPositionMilliseconds);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SkipBackward.
+namespace PlaybackResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PlaybackResponse.
+namespace Seek {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPosition), position);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPosition))
+ {
+ err = DataModel::Decode(reader, position);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Seek.
+namespace ActivateAudioTrack {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTrackID), trackID);
+ encoder.Encode(to_underlying(Fields::kAudioOutputIndex), audioOutputIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTrackID))
+ {
+ err = DataModel::Decode(reader, trackID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioOutputIndex))
+ {
+ err = DataModel::Decode(reader, audioOutputIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ActivateAudioTrack.
+namespace ActivateTextTrack {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTrackID), trackID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTrackID))
+ {
+ err = DataModel::Decode(reader, trackID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ActivateTextTrack.
+namespace DeactivateTextTrack {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace DeactivateTextTrack.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CurrentState::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentState);
+ case Attributes::StartTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, startTime);
+ case Attributes::Duration::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, duration);
+ case Attributes::SampledPosition::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sampledPosition);
+ case Attributes::PlaybackSpeed::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, playbackSpeed);
+ case Attributes::SeekRangeEnd::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, seekRangeEnd);
+ case Attributes::SeekRangeStart::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, seekRangeStart);
+ case Attributes::ActiveAudioTrack::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeAudioTrack);
+ case Attributes::AvailableAudioTracks::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, availableAudioTracks);
+ case Attributes::ActiveTextTrack::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeTextTrack);
+ case Attributes::AvailableTextTracks::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, availableTextTracks);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace StateChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentState), currentState));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStartTime), startTime));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDuration), duration));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSampledPosition), sampledPosition));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPlaybackSpeed), playbackSpeed));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSeekRangeEnd), seekRangeEnd));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSeekRangeStart), seekRangeStart));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kData), data));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAudioAdvanceUnmuted), audioAdvanceUnmuted));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCurrentState))
+ {
+ err = DataModel::Decode(reader, currentState);
+ }
+ else if (__context_tag == to_underlying(Fields::kStartTime))
+ {
+ err = DataModel::Decode(reader, startTime);
+ }
+ else if (__context_tag == to_underlying(Fields::kDuration))
+ {
+ err = DataModel::Decode(reader, duration);
+ }
+ else if (__context_tag == to_underlying(Fields::kSampledPosition))
+ {
+ err = DataModel::Decode(reader, sampledPosition);
+ }
+ else if (__context_tag == to_underlying(Fields::kPlaybackSpeed))
+ {
+ err = DataModel::Decode(reader, playbackSpeed);
+ }
+ else if (__context_tag == to_underlying(Fields::kSeekRangeEnd))
+ {
+ err = DataModel::Decode(reader, seekRangeEnd);
+ }
+ else if (__context_tag == to_underlying(Fields::kSeekRangeStart))
+ {
+ err = DataModel::Decode(reader, seekRangeStart);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioAdvanceUnmuted))
+ {
+ err = DataModel::Decode(reader, audioAdvanceUnmuted);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StateChanged.
+} // namespace Events
+
+} // namespace MediaPlayback
+namespace MediaInput {
+namespace Structs {
+
+namespace InputInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIndex), index);
+ encoder.Encode(to_underlying(Fields::kInputType), inputType);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kDescription), description);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIndex))
+ {
+ err = DataModel::Decode(reader, index);
+ }
+ else if (__context_tag == to_underlying(Fields::kInputType))
+ {
+ err = DataModel::Decode(reader, inputType);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kDescription))
+ {
+ err = DataModel::Decode(reader, description);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace InputInfoStruct
+} // namespace Structs
+
+namespace Commands {
+namespace SelectInput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIndex), index);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIndex))
+ {
+ err = DataModel::Decode(reader, index);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SelectInput.
+namespace ShowInputStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ShowInputStatus.
+namespace HideInputStatus {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace HideInputStatus.
+namespace RenameInput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIndex), index);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIndex))
+ {
+ err = DataModel::Decode(reader, index);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RenameInput.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::InputList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, inputList);
+ case Attributes::CurrentInput::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentInput);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace MediaInput
+namespace LowPower {
+
+namespace Commands {
+namespace Sleep {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Sleep.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace LowPower
+namespace KeypadInput {
+
+namespace Commands {
+namespace SendKey {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kKeyCode), keyCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kKeyCode))
+ {
+ err = DataModel::Decode(reader, keyCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SendKey.
+namespace SendKeyResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SendKeyResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace KeypadInput
+namespace ContentLauncher {
+namespace Structs {
+
+namespace DimensionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWidth), width);
+ encoder.Encode(to_underlying(Fields::kHeight), height);
+ encoder.Encode(to_underlying(Fields::kMetric), metric);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWidth))
+ {
+ err = DataModel::Decode(reader, width);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeight))
+ {
+ err = DataModel::Decode(reader, height);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetric))
+ {
+ err = DataModel::Decode(reader, metric);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace DimensionStruct
+
+namespace TrackPreferenceStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kLanguageCode), languageCode);
+ encoder.Encode(to_underlying(Fields::kCharacteristics), characteristics);
+ encoder.Encode(to_underlying(Fields::kAudioOutputIndex), audioOutputIndex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kLanguageCode))
+ {
+ err = DataModel::Decode(reader, languageCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kCharacteristics))
+ {
+ err = DataModel::Decode(reader, characteristics);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioOutputIndex))
+ {
+ err = DataModel::Decode(reader, audioOutputIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TrackPreferenceStruct
+
+namespace PlaybackPreferencesStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPlaybackPosition), playbackPosition);
+ encoder.Encode(to_underlying(Fields::kTextTrack), textTrack);
+ encoder.Encode(to_underlying(Fields::kAudioTracks), audioTracks);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPlaybackPosition))
+ {
+ err = DataModel::Decode(reader, playbackPosition);
+ }
+ else if (__context_tag == to_underlying(Fields::kTextTrack))
+ {
+ err = DataModel::Decode(reader, textTrack);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioTracks))
+ {
+ err = DataModel::Decode(reader, audioTracks);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace PlaybackPreferencesStruct
+
+namespace AdditionalInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AdditionalInfoStruct
+
+namespace ParameterStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kType), type);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else if (__context_tag == to_underlying(Fields::kExternalIDList))
+ {
+ err = DataModel::Decode(reader, externalIDList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ParameterStruct
+
+namespace ContentSearchStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kParameterList), parameterList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kParameterList))
+ {
+ err = DataModel::Decode(reader, parameterList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ContentSearchStruct
+
+namespace StyleInformationStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kImageURL), imageURL);
+ encoder.Encode(to_underlying(Fields::kColor), color);
+ encoder.Encode(to_underlying(Fields::kSize), size);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kImageURL))
+ {
+ err = DataModel::Decode(reader, imageURL);
+ }
+ else if (__context_tag == to_underlying(Fields::kColor))
+ {
+ err = DataModel::Decode(reader, color);
+ }
+ else if (__context_tag == to_underlying(Fields::kSize))
+ {
+ err = DataModel::Decode(reader, size);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace StyleInformationStruct
+
+namespace BrandingInformationStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kProviderName), providerName);
+ encoder.Encode(to_underlying(Fields::kBackground), background);
+ encoder.Encode(to_underlying(Fields::kLogo), logo);
+ encoder.Encode(to_underlying(Fields::kProgressBar), progressBar);
+ encoder.Encode(to_underlying(Fields::kSplash), splash);
+ encoder.Encode(to_underlying(Fields::kWaterMark), waterMark);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kProviderName))
+ {
+ err = DataModel::Decode(reader, providerName);
+ }
+ else if (__context_tag == to_underlying(Fields::kBackground))
+ {
+ err = DataModel::Decode(reader, background);
+ }
+ else if (__context_tag == to_underlying(Fields::kLogo))
+ {
+ err = DataModel::Decode(reader, logo);
+ }
+ else if (__context_tag == to_underlying(Fields::kProgressBar))
+ {
+ err = DataModel::Decode(reader, progressBar);
+ }
+ else if (__context_tag == to_underlying(Fields::kSplash))
+ {
+ err = DataModel::Decode(reader, splash);
+ }
+ else if (__context_tag == to_underlying(Fields::kWaterMark))
+ {
+ err = DataModel::Decode(reader, waterMark);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace BrandingInformationStruct
+} // namespace Structs
+
+namespace Commands {
+namespace LaunchContent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSearch), search);
+ encoder.Encode(to_underlying(Fields::kAutoPlay), autoPlay);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ encoder.Encode(to_underlying(Fields::kPlaybackPreferences), playbackPreferences);
+ encoder.Encode(to_underlying(Fields::kUseCurrentContext), useCurrentContext);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSearch))
+ {
+ err = DataModel::Decode(reader, search);
+ }
+ else if (__context_tag == to_underlying(Fields::kAutoPlay))
+ {
+ err = DataModel::Decode(reader, autoPlay);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else if (__context_tag == to_underlying(Fields::kPlaybackPreferences))
+ {
+ err = DataModel::Decode(reader, playbackPreferences);
+ }
+ else if (__context_tag == to_underlying(Fields::kUseCurrentContext))
+ {
+ err = DataModel::Decode(reader, useCurrentContext);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LaunchContent.
+namespace LaunchURL {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kContentURL), contentURL);
+ encoder.Encode(to_underlying(Fields::kDisplayString), displayString);
+ encoder.Encode(to_underlying(Fields::kBrandingInformation), brandingInformation);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kContentURL))
+ {
+ err = DataModel::Decode(reader, contentURL);
+ }
+ else if (__context_tag == to_underlying(Fields::kDisplayString))
+ {
+ err = DataModel::Decode(reader, displayString);
+ }
+ else if (__context_tag == to_underlying(Fields::kBrandingInformation))
+ {
+ err = DataModel::Decode(reader, brandingInformation);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LaunchURL.
+namespace LauncherResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LauncherResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::AcceptHeader::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptHeader);
+ case Attributes::SupportedStreamingProtocols::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedStreamingProtocols);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ContentLauncher
+namespace AudioOutput {
+namespace Structs {
+
+namespace OutputInfoStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIndex), index);
+ encoder.Encode(to_underlying(Fields::kOutputType), outputType);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIndex))
+ {
+ err = DataModel::Decode(reader, index);
+ }
+ else if (__context_tag == to_underlying(Fields::kOutputType))
+ {
+ err = DataModel::Decode(reader, outputType);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace OutputInfoStruct
+} // namespace Structs
+
+namespace Commands {
+namespace SelectOutput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIndex), index);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIndex))
+ {
+ err = DataModel::Decode(reader, index);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SelectOutput.
+namespace RenameOutput {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kIndex), index);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kIndex))
+ {
+ err = DataModel::Decode(reader, index);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RenameOutput.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::OutputList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, outputList);
+ case Attributes::CurrentOutput::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentOutput);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace AudioOutput
+namespace ApplicationLauncher {
+namespace Structs {
+
+namespace ApplicationEPStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kApplication), application);
+ encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kApplication))
+ {
+ err = DataModel::Decode(reader, application);
+ }
+ else if (__context_tag == to_underlying(Fields::kEndpoint))
+ {
+ err = DataModel::Decode(reader, endpoint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ApplicationEPStruct
+} // namespace Structs
+
+namespace Commands {
+namespace LaunchApp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kApplication), application);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kApplication))
+ {
+ err = DataModel::Decode(reader, application);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LaunchApp.
+namespace StopApp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kApplication), application);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kApplication))
+ {
+ err = DataModel::Decode(reader, application);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StopApp.
+namespace HideApp {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kApplication), application);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kApplication))
+ {
+ err = DataModel::Decode(reader, application);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace HideApp.
+namespace LauncherResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LauncherResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CatalogList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, catalogList);
+ case Attributes::CurrentApp::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentApp);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ApplicationLauncher
+namespace ApplicationBasic {
+namespace Structs {} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::VendorName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorName);
+ case Attributes::VendorID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorID);
+ case Attributes::ApplicationName::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, applicationName);
+ case Attributes::ProductID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, productID);
+ case Attributes::Application::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, application);
+ case Attributes::Status::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, status);
+ case Attributes::ApplicationVersion::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, applicationVersion);
+ case Attributes::AllowedVendorList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, allowedVendorList);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ApplicationBasic
+namespace AccountLogin {
+
+namespace Commands {
+namespace GetSetupPIN {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTempAccountIdentifier), tempAccountIdentifier);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTempAccountIdentifier))
+ {
+ err = DataModel::Decode(reader, tempAccountIdentifier);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetSetupPIN.
+namespace GetSetupPINResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSetupPIN), setupPIN);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSetupPIN))
+ {
+ err = DataModel::Decode(reader, setupPIN);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetSetupPINResponse.
+namespace Login {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kTempAccountIdentifier), tempAccountIdentifier);
+ encoder.Encode(to_underlying(Fields::kSetupPIN), setupPIN);
+ encoder.Encode(to_underlying(Fields::kNode), node);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kTempAccountIdentifier))
+ {
+ err = DataModel::Decode(reader, tempAccountIdentifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kSetupPIN))
+ {
+ err = DataModel::Decode(reader, setupPIN);
+ }
+ else if (__context_tag == to_underlying(Fields::kNode))
+ {
+ err = DataModel::Decode(reader, node);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Login.
+namespace Logout {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNode), node);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNode))
+ {
+ err = DataModel::Decode(reader, node);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Logout.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace LoggedOut {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNode), node));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNode))
+ {
+ err = DataModel::Decode(reader, node);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace LoggedOut.
+} // namespace Events
+
+} // namespace AccountLogin
+namespace ContentControl {
+namespace Structs {
+
+namespace RatingNameStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRatingName), ratingName);
+ encoder.Encode(to_underlying(Fields::kRatingNameDesc), ratingNameDesc);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRatingName))
+ {
+ err = DataModel::Decode(reader, ratingName);
+ }
+ else if (__context_tag == to_underlying(Fields::kRatingNameDesc))
+ {
+ err = DataModel::Decode(reader, ratingNameDesc);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace RatingNameStruct
+} // namespace Structs
+
+namespace Commands {
+namespace UpdatePIN {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kOldPIN), oldPIN);
+ encoder.Encode(to_underlying(Fields::kNewPIN), newPIN);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kOldPIN))
+ {
+ err = DataModel::Decode(reader, oldPIN);
+ }
+ else if (__context_tag == to_underlying(Fields::kNewPIN))
+ {
+ err = DataModel::Decode(reader, newPIN);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UpdatePIN.
+namespace ResetPIN {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace ResetPIN.
+namespace ResetPINResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPINCode))
+ {
+ err = DataModel::Decode(reader, PINCode);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ResetPINResponse.
+namespace Enable {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Enable.
+namespace Disable {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Disable.
+namespace AddBonusTime {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
+ encoder.Encode(to_underlying(Fields::kBonusTime), bonusTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPINCode))
+ {
+ err = DataModel::Decode(reader, PINCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kBonusTime))
+ {
+ err = DataModel::Decode(reader, bonusTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddBonusTime.
+namespace SetScreenDailyTime {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kScreenTime), screenTime);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kScreenTime))
+ {
+ err = DataModel::Decode(reader, screenTime);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetScreenDailyTime.
+namespace BlockUnratedContent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace BlockUnratedContent.
+namespace UnblockUnratedContent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace UnblockUnratedContent.
+namespace SetOnDemandRatingThreshold {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRating), rating);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRating))
+ {
+ err = DataModel::Decode(reader, rating);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetOnDemandRatingThreshold.
+namespace SetScheduledContentRatingThreshold {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRating), rating);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRating))
+ {
+ err = DataModel::Decode(reader, rating);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetScheduledContentRatingThreshold.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Enabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enabled);
+ case Attributes::OnDemandRatings::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onDemandRatings);
+ case Attributes::OnDemandRatingThreshold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, onDemandRatingThreshold);
+ case Attributes::ScheduledContentRatings::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scheduledContentRatings);
+ case Attributes::ScheduledContentRatingThreshold::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, scheduledContentRatingThreshold);
+ case Attributes::ScreenDailyTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, screenDailyTime);
+ case Attributes::RemainingScreenTime::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, remainingScreenTime);
+ case Attributes::BlockUnrated::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, blockUnrated);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace RemainingScreenTimeExpired {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace RemainingScreenTimeExpired.
+} // namespace Events
+
+} // namespace ContentControl
+namespace ContentAppObserver {
+
+namespace Commands {
+namespace ContentAppMessage {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kData), data);
+ encoder.Encode(to_underlying(Fields::kEncodingHint), encodingHint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else if (__context_tag == to_underlying(Fields::kEncodingHint))
+ {
+ err = DataModel::Decode(reader, encodingHint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ContentAppMessage.
+namespace ContentAppMessageResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStatus), status);
+ encoder.Encode(to_underlying(Fields::kData), data);
+ encoder.Encode(to_underlying(Fields::kEncodingHint), encodingHint);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStatus))
+ {
+ err = DataModel::Decode(reader, status);
+ }
+ else if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else if (__context_tag == to_underlying(Fields::kEncodingHint))
+ {
+ err = DataModel::Decode(reader, encodingHint);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ContentAppMessageResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace ContentAppObserver
+namespace ZoneManagement {
+namespace Structs {
+
+namespace TwoDCartesianVertexStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kX), x);
+ encoder.Encode(to_underlying(Fields::kY), y);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kX))
+ {
+ err = DataModel::Decode(reader, x);
+ }
+ else if (__context_tag == to_underlying(Fields::kY))
+ {
+ err = DataModel::Decode(reader, y);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TwoDCartesianVertexStruct
+
+namespace TwoDCartesianZoneStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kUse), use);
+ encoder.Encode(to_underlying(Fields::kVertices), vertices);
+ encoder.Encode(to_underlying(Fields::kColor), color);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kUse))
+ {
+ err = DataModel::Decode(reader, use);
+ }
+ else if (__context_tag == to_underlying(Fields::kVertices))
+ {
+ err = DataModel::Decode(reader, vertices);
+ }
+ else if (__context_tag == to_underlying(Fields::kColor))
+ {
+ err = DataModel::Decode(reader, color);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TwoDCartesianZoneStruct
+
+namespace ZoneInformationStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
+ encoder.Encode(to_underlying(Fields::kZoneType), zoneType);
+ encoder.Encode(to_underlying(Fields::kZoneSource), zoneSource);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZoneID))
+ {
+ err = DataModel::Decode(reader, zoneID);
+ }
+ else if (__context_tag == to_underlying(Fields::kZoneType))
+ {
+ err = DataModel::Decode(reader, zoneType);
+ }
+ else if (__context_tag == to_underlying(Fields::kZoneSource))
+ {
+ err = DataModel::Decode(reader, zoneSource);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ZoneInformationStruct
+
+namespace ZoneTriggerControlStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kInitialDuration), initialDuration);
+ encoder.Encode(to_underlying(Fields::kAugmentationDuration), augmentationDuration);
+ encoder.Encode(to_underlying(Fields::kMaxDuration), maxDuration);
+ encoder.Encode(to_underlying(Fields::kBlindDuration), blindDuration);
+ encoder.Encode(to_underlying(Fields::kSensitivity), sensitivity);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kInitialDuration))
+ {
+ err = DataModel::Decode(reader, initialDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kAugmentationDuration))
+ {
+ err = DataModel::Decode(reader, augmentationDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxDuration))
+ {
+ err = DataModel::Decode(reader, maxDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kBlindDuration))
+ {
+ err = DataModel::Decode(reader, blindDuration);
+ }
+ else if (__context_tag == to_underlying(Fields::kSensitivity))
+ {
+ err = DataModel::Decode(reader, sensitivity);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ZoneTriggerControlStruct
+} // namespace Structs
+
+namespace Commands {
+namespace CreateTwoDCartesianZone {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZone), zone);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZone))
+ {
+ err = DataModel::Decode(reader, zone);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CreateTwoDCartesianZone.
+namespace CreateTwoDCartesianZoneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZoneID))
+ {
+ err = DataModel::Decode(reader, zoneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CreateTwoDCartesianZoneResponse.
+namespace UpdateTwoDCartesianZone {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
+ encoder.Encode(to_underlying(Fields::kZone), zone);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZoneID))
+ {
+ err = DataModel::Decode(reader, zoneID);
+ }
+ else if (__context_tag == to_underlying(Fields::kZone))
+ {
+ err = DataModel::Decode(reader, zone);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace UpdateTwoDCartesianZone.
+namespace GetTwoDCartesianZone {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZoneID))
+ {
+ err = DataModel::Decode(reader, zoneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetTwoDCartesianZone.
+namespace GetTwoDCartesianZoneResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZones), zones);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZones))
+ {
+ err = DataModel::Decode(reader, zones);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GetTwoDCartesianZoneResponse.
+namespace RemoveZone {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZoneID))
+ {
+ err = DataModel::Decode(reader, zoneID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RemoveZone.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedZoneSources::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedZoneSources);
+ case Attributes::Zones::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, zones);
+ case Attributes::Triggers::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, triggers);
+ case Attributes::Sensitivity::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, sensitivity);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace ZoneTriggered {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kZones), zones));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZones))
+ {
+ err = DataModel::Decode(reader, zones);
+ }
+ else if (__context_tag == to_underlying(Fields::kReason))
+ {
+ err = DataModel::Decode(reader, reason);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ZoneTriggered.
+namespace ZoneStopped {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kZones), zones));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kZones))
+ {
+ err = DataModel::Decode(reader, zones);
+ }
+ else if (__context_tag == to_underlying(Fields::kReason))
+ {
+ err = DataModel::Decode(reader, reason);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ZoneStopped.
+} // namespace Events
+
+} // namespace ZoneManagement
+namespace CameraAvStreamManagement {
+namespace Structs {
+
+namespace VideoResolutionStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWidth), width);
+ encoder.Encode(to_underlying(Fields::kHeight), height);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWidth))
+ {
+ err = DataModel::Decode(reader, width);
+ }
+ else if (__context_tag == to_underlying(Fields::kHeight))
+ {
+ err = DataModel::Decode(reader, height);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace VideoResolutionStruct
+
+namespace VideoStreamStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kVideoCodec), videoCodec);
+ encoder.Encode(to_underlying(Fields::kMinFrameRate), minFrameRate);
+ encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
+ encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
+ encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
+ encoder.Encode(to_underlying(Fields::kMinBitRate), minBitRate);
+ encoder.Encode(to_underlying(Fields::kMaxBitRate), maxBitRate);
+ encoder.Encode(to_underlying(Fields::kMinFragmentLen), minFragmentLen);
+ encoder.Encode(to_underlying(Fields::kMaxFragmentLen), maxFragmentLen);
+ encoder.Encode(to_underlying(Fields::kWatermarkEnabled), watermarkEnabled);
+ encoder.Encode(to_underlying(Fields::kOSDEnabled), OSDEnabled);
+ encoder.Encode(to_underlying(Fields::kReferenceCount), referenceCount);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoCodec))
+ {
+ err = DataModel::Decode(reader, videoCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinFrameRate))
+ {
+ err = DataModel::Decode(reader, minFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
+ {
+ err = DataModel::Decode(reader, maxFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinResolution))
+ {
+ err = DataModel::Decode(reader, minResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxResolution))
+ {
+ err = DataModel::Decode(reader, maxResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinBitRate))
+ {
+ err = DataModel::Decode(reader, minBitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxBitRate))
+ {
+ err = DataModel::Decode(reader, maxBitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinFragmentLen))
+ {
+ err = DataModel::Decode(reader, minFragmentLen);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFragmentLen))
+ {
+ err = DataModel::Decode(reader, maxFragmentLen);
+ }
+ else if (__context_tag == to_underlying(Fields::kWatermarkEnabled))
+ {
+ err = DataModel::Decode(reader, watermarkEnabled);
+ }
+ else if (__context_tag == to_underlying(Fields::kOSDEnabled))
+ {
+ err = DataModel::Decode(reader, OSDEnabled);
+ }
+ else if (__context_tag == to_underlying(Fields::kReferenceCount))
+ {
+ err = DataModel::Decode(reader, referenceCount);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace VideoStreamStruct
+
+namespace SnapshotStreamStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
+ encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
+ encoder.Encode(to_underlying(Fields::kFrameRate), frameRate);
+ encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
+ encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
+ encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
+ encoder.Encode(to_underlying(Fields::kQuality), quality);
+ encoder.Encode(to_underlying(Fields::kReferenceCount), referenceCount);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
+ {
+ err = DataModel::Decode(reader, snapshotStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kImageCodec))
+ {
+ err = DataModel::Decode(reader, imageCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kFrameRate))
+ {
+ err = DataModel::Decode(reader, frameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitRate))
+ {
+ err = DataModel::Decode(reader, bitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinResolution))
+ {
+ err = DataModel::Decode(reader, minResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxResolution))
+ {
+ err = DataModel::Decode(reader, maxResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kQuality))
+ {
+ err = DataModel::Decode(reader, quality);
+ }
+ else if (__context_tag == to_underlying(Fields::kReferenceCount))
+ {
+ err = DataModel::Decode(reader, referenceCount);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SnapshotStreamStruct
+
+namespace SnapshotParamsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kResolution), resolution);
+ encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
+ encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kResolution))
+ {
+ err = DataModel::Decode(reader, resolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
+ {
+ err = DataModel::Decode(reader, maxFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kImageCodec))
+ {
+ err = DataModel::Decode(reader, imageCodec);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SnapshotParamsStruct
+
+namespace RateDistortionTradeOffPointsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCodec), codec);
+ encoder.Encode(to_underlying(Fields::kResolution), resolution);
+ encoder.Encode(to_underlying(Fields::kMinBitRate), minBitRate);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCodec))
+ {
+ err = DataModel::Decode(reader, codec);
+ }
+ else if (__context_tag == to_underlying(Fields::kResolution))
+ {
+ err = DataModel::Decode(reader, resolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinBitRate))
+ {
+ err = DataModel::Decode(reader, minBitRate);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace RateDistortionTradeOffPointsStruct
+
+namespace AudioCapabilitiesStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMaxNumberOfChannels), maxNumberOfChannels);
+ encoder.Encode(to_underlying(Fields::kSupportedCodecs), supportedCodecs);
+ encoder.Encode(to_underlying(Fields::kSupportedSampleRates), supportedSampleRates);
+ encoder.Encode(to_underlying(Fields::kSupportedBitDepths), supportedBitDepths);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMaxNumberOfChannels))
+ {
+ err = DataModel::Decode(reader, maxNumberOfChannels);
+ }
+ else if (__context_tag == to_underlying(Fields::kSupportedCodecs))
+ {
+ err = DataModel::Decode(reader, supportedCodecs);
+ }
+ else if (__context_tag == to_underlying(Fields::kSupportedSampleRates))
+ {
+ err = DataModel::Decode(reader, supportedSampleRates);
+ }
+ else if (__context_tag == to_underlying(Fields::kSupportedBitDepths))
+ {
+ err = DataModel::Decode(reader, supportedBitDepths);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AudioCapabilitiesStruct
+
+namespace AudioStreamStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kAudioCodec), audioCodec);
+ encoder.Encode(to_underlying(Fields::kChannelCount), channelCount);
+ encoder.Encode(to_underlying(Fields::kSampleRate), sampleRate);
+ encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
+ encoder.Encode(to_underlying(Fields::kBitDepth), bitDepth);
+ encoder.Encode(to_underlying(Fields::kReferenceCount), referenceCount);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioCodec))
+ {
+ err = DataModel::Decode(reader, audioCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannelCount))
+ {
+ err = DataModel::Decode(reader, channelCount);
+ }
+ else if (__context_tag == to_underlying(Fields::kSampleRate))
+ {
+ err = DataModel::Decode(reader, sampleRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitRate))
+ {
+ err = DataModel::Decode(reader, bitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitDepth))
+ {
+ err = DataModel::Decode(reader, bitDepth);
+ }
+ else if (__context_tag == to_underlying(Fields::kReferenceCount))
+ {
+ err = DataModel::Decode(reader, referenceCount);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace AudioStreamStruct
+
+namespace VideoSensorParamsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSensorWidth), sensorWidth);
+ encoder.Encode(to_underlying(Fields::kSensorHeight), sensorHeight);
+ encoder.Encode(to_underlying(Fields::kHDRCapable), HDRCapable);
+ encoder.Encode(to_underlying(Fields::kMaxFPS), maxFPS);
+ encoder.Encode(to_underlying(Fields::kMaxHDRFPS), maxHDRFPS);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSensorWidth))
+ {
+ err = DataModel::Decode(reader, sensorWidth);
+ }
+ else if (__context_tag == to_underlying(Fields::kSensorHeight))
+ {
+ err = DataModel::Decode(reader, sensorHeight);
+ }
+ else if (__context_tag == to_underlying(Fields::kHDRCapable))
+ {
+ err = DataModel::Decode(reader, HDRCapable);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFPS))
+ {
+ err = DataModel::Decode(reader, maxFPS);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxHDRFPS))
+ {
+ err = DataModel::Decode(reader, maxHDRFPS);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace VideoSensorParamsStruct
+} // namespace Structs
+
+namespace Commands {
+namespace AudioStreamAllocate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kAudioCodec), audioCodec);
+ encoder.Encode(to_underlying(Fields::kChannelCount), channelCount);
+ encoder.Encode(to_underlying(Fields::kSampleRate), sampleRate);
+ encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
+ encoder.Encode(to_underlying(Fields::kBitDepth), bitDepth);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioCodec))
+ {
+ err = DataModel::Decode(reader, audioCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannelCount))
+ {
+ err = DataModel::Decode(reader, channelCount);
+ }
+ else if (__context_tag == to_underlying(Fields::kSampleRate))
+ {
+ err = DataModel::Decode(reader, sampleRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitRate))
+ {
+ err = DataModel::Decode(reader, bitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitDepth))
+ {
+ err = DataModel::Decode(reader, bitDepth);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AudioStreamAllocate.
+namespace AudioStreamAllocateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AudioStreamAllocateResponse.
+namespace AudioStreamDeallocate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AudioStreamDeallocate.
+namespace VideoStreamAllocate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kVideoCodec), videoCodec);
+ encoder.Encode(to_underlying(Fields::kMinFrameRate), minFrameRate);
+ encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
+ encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
+ encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
+ encoder.Encode(to_underlying(Fields::kMinBitRate), minBitRate);
+ encoder.Encode(to_underlying(Fields::kMaxBitRate), maxBitRate);
+ encoder.Encode(to_underlying(Fields::kMinFragmentLen), minFragmentLen);
+ encoder.Encode(to_underlying(Fields::kMaxFragmentLen), maxFragmentLen);
+ encoder.Encode(to_underlying(Fields::kWatermarkEnabled), watermarkEnabled);
+ encoder.Encode(to_underlying(Fields::kOSDEnabled), OSDEnabled);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoCodec))
+ {
+ err = DataModel::Decode(reader, videoCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinFrameRate))
+ {
+ err = DataModel::Decode(reader, minFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
+ {
+ err = DataModel::Decode(reader, maxFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinResolution))
+ {
+ err = DataModel::Decode(reader, minResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxResolution))
+ {
+ err = DataModel::Decode(reader, maxResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinBitRate))
+ {
+ err = DataModel::Decode(reader, minBitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxBitRate))
+ {
+ err = DataModel::Decode(reader, maxBitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinFragmentLen))
+ {
+ err = DataModel::Decode(reader, minFragmentLen);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFragmentLen))
+ {
+ err = DataModel::Decode(reader, maxFragmentLen);
+ }
+ else if (__context_tag == to_underlying(Fields::kWatermarkEnabled))
+ {
+ err = DataModel::Decode(reader, watermarkEnabled);
+ }
+ else if (__context_tag == to_underlying(Fields::kOSDEnabled))
+ {
+ err = DataModel::Decode(reader, OSDEnabled);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace VideoStreamAllocate.
+namespace VideoStreamAllocateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace VideoStreamAllocateResponse.
+namespace VideoStreamModify {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kWatermarkEnabled), watermarkEnabled);
+ encoder.Encode(to_underlying(Fields::kOSDEnabled), OSDEnabled);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kWatermarkEnabled))
+ {
+ err = DataModel::Decode(reader, watermarkEnabled);
+ }
+ else if (__context_tag == to_underlying(Fields::kOSDEnabled))
+ {
+ err = DataModel::Decode(reader, OSDEnabled);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace VideoStreamModify.
+namespace VideoStreamDeallocate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace VideoStreamDeallocate.
+namespace SnapshotStreamAllocate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
+ encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
+ encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
+ encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
+ encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
+ encoder.Encode(to_underlying(Fields::kQuality), quality);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kImageCodec))
+ {
+ err = DataModel::Decode(reader, imageCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
+ {
+ err = DataModel::Decode(reader, maxFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitRate))
+ {
+ err = DataModel::Decode(reader, bitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinResolution))
+ {
+ err = DataModel::Decode(reader, minResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxResolution))
+ {
+ err = DataModel::Decode(reader, maxResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kQuality))
+ {
+ err = DataModel::Decode(reader, quality);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SnapshotStreamAllocate.
+namespace SnapshotStreamAllocateResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
+ {
+ err = DataModel::Decode(reader, snapshotStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SnapshotStreamAllocateResponse.
+namespace SnapshotStreamDeallocate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
+ {
+ err = DataModel::Decode(reader, snapshotStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SnapshotStreamDeallocate.
+namespace SetStreamPriorities {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStreamPriorities), streamPriorities);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStreamPriorities))
+ {
+ err = DataModel::Decode(reader, streamPriorities);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SetStreamPriorities.
+namespace CaptureSnapshot {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
+ encoder.Encode(to_underlying(Fields::kRequestedResolution), requestedResolution);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
+ {
+ err = DataModel::Decode(reader, snapshotStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kRequestedResolution))
+ {
+ err = DataModel::Decode(reader, requestedResolution);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CaptureSnapshot.
+namespace CaptureSnapshotResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kData), data);
+ encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
+ encoder.Encode(to_underlying(Fields::kResolution), resolution);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kData))
+ {
+ err = DataModel::Decode(reader, data);
+ }
+ else if (__context_tag == to_underlying(Fields::kImageCodec))
+ {
+ err = DataModel::Decode(reader, imageCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kResolution))
+ {
+ err = DataModel::Decode(reader, resolution);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CaptureSnapshotResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MaxConcurrentVideoEncoders::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxConcurrentVideoEncoders);
+ case Attributes::MaxEncodedPixelRate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxEncodedPixelRate);
+ case Attributes::VideoSensorParams::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, videoSensorParams);
+ case Attributes::NightVisionCapable::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nightVisionCapable);
+ case Attributes::MinViewport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, minViewport);
+ case Attributes::RateDistortionTradeOffPoints::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rateDistortionTradeOffPoints);
+ case Attributes::MaxContentBufferSize::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxContentBufferSize);
+ case Attributes::MicrophoneCapabilities::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, microphoneCapabilities);
+ case Attributes::SpeakerCapabilities::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speakerCapabilities);
+ case Attributes::TwoWayTalkSupport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, twoWayTalkSupport);
+ case Attributes::SupportedSnapshotParams::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedSnapshotParams);
+ case Attributes::MaxNetworkBandwidth::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxNetworkBandwidth);
+ case Attributes::CurrentFrameRate::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentFrameRate);
+ case Attributes::HDRModeEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, HDRModeEnabled);
+ case Attributes::FabricsUsingCamera::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, fabricsUsingCamera);
+ case Attributes::AllocatedVideoStreams::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, allocatedVideoStreams);
+ case Attributes::AllocatedAudioStreams::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, allocatedAudioStreams);
+ case Attributes::AllocatedSnapshotStreams::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, allocatedSnapshotStreams);
+ case Attributes::RankedVideoStreamPrioritiesList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rankedVideoStreamPrioritiesList);
+ case Attributes::SoftRecordingPrivacyModeEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, softRecordingPrivacyModeEnabled);
+ case Attributes::SoftLivestreamPrivacyModeEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, softLivestreamPrivacyModeEnabled);
+ case Attributes::HardPrivacyModeOn::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, hardPrivacyModeOn);
+ case Attributes::NightVision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nightVision);
+ case Attributes::NightVisionIllum::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nightVisionIllum);
+ case Attributes::Viewport::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, viewport);
+ case Attributes::SpeakerMuted::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speakerMuted);
+ case Attributes::SpeakerVolumeLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speakerVolumeLevel);
+ case Attributes::SpeakerMaxLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speakerMaxLevel);
+ case Attributes::SpeakerMinLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, speakerMinLevel);
+ case Attributes::MicrophoneMuted::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, microphoneMuted);
+ case Attributes::MicrophoneVolumeLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, microphoneVolumeLevel);
+ case Attributes::MicrophoneMaxLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, microphoneMaxLevel);
+ case Attributes::MicrophoneMinLevel::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, microphoneMinLevel);
+ case Attributes::MicrophoneAGCEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, microphoneAGCEnabled);
+ case Attributes::ImageRotation::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, imageRotation);
+ case Attributes::ImageFlipHorizontal::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, imageFlipHorizontal);
+ case Attributes::ImageFlipVertical::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, imageFlipVertical);
+ case Attributes::LocalVideoRecordingEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localVideoRecordingEnabled);
+ case Attributes::LocalSnapshotRecordingEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, localSnapshotRecordingEnabled);
+ case Attributes::StatusLightEnabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, statusLightEnabled);
+ case Attributes::StatusLightBrightness::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, statusLightBrightness);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace VideoStreamChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kVideoStreamID), videoStreamID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStreamUsage), streamUsage));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kVideoCodec), videoCodec));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinFrameRate), minFrameRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxFrameRate), maxFrameRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinResolution), minResolution));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxResolution), maxResolution));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinBitRate), minBitRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxBitRate), maxBitRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinFragmentLen), minFragmentLen));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxFragmentLen), maxFragmentLen));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoCodec))
+ {
+ err = DataModel::Decode(reader, videoCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinFrameRate))
+ {
+ err = DataModel::Decode(reader, minFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
+ {
+ err = DataModel::Decode(reader, maxFrameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinResolution))
+ {
+ err = DataModel::Decode(reader, minResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxResolution))
+ {
+ err = DataModel::Decode(reader, maxResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinBitRate))
+ {
+ err = DataModel::Decode(reader, minBitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxBitRate))
+ {
+ err = DataModel::Decode(reader, maxBitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinFragmentLen))
+ {
+ err = DataModel::Decode(reader, minFragmentLen);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxFragmentLen))
+ {
+ err = DataModel::Decode(reader, maxFragmentLen);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace VideoStreamChanged.
+namespace AudioStreamChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAudioStreamID), audioStreamID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStreamUsage), streamUsage));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAudioCodec), audioCodec));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kChannelCount), channelCount));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSampleRate), sampleRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBitRate), bitRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBitDepth), bitDepth));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioCodec))
+ {
+ err = DataModel::Decode(reader, audioCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kChannelCount))
+ {
+ err = DataModel::Decode(reader, channelCount);
+ }
+ else if (__context_tag == to_underlying(Fields::kSampleRate))
+ {
+ err = DataModel::Decode(reader, sampleRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitRate))
+ {
+ err = DataModel::Decode(reader, bitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitDepth))
+ {
+ err = DataModel::Decode(reader, bitDepth);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AudioStreamChanged.
+namespace SnapshotStreamChanged {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSnapshotStreamID), snapshotStreamID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kImageCodec), imageCodec));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFrameRate), frameRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBitRate), bitRate));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinResolution), minResolution));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxResolution), maxResolution));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kQuality), quality));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
+ {
+ err = DataModel::Decode(reader, snapshotStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kImageCodec))
+ {
+ err = DataModel::Decode(reader, imageCodec);
+ }
+ else if (__context_tag == to_underlying(Fields::kFrameRate))
+ {
+ err = DataModel::Decode(reader, frameRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kBitRate))
+ {
+ err = DataModel::Decode(reader, bitRate);
+ }
+ else if (__context_tag == to_underlying(Fields::kMinResolution))
+ {
+ err = DataModel::Decode(reader, minResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kMaxResolution))
+ {
+ err = DataModel::Decode(reader, maxResolution);
+ }
+ else if (__context_tag == to_underlying(Fields::kQuality))
+ {
+ err = DataModel::Decode(reader, quality);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SnapshotStreamChanged.
+} // namespace Events
+
+} // namespace CameraAvStreamManagement
+namespace CameraAvSettingsUserLevelManagement {
+namespace Structs {
+
+namespace MPTZStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPan), pan);
+ encoder.Encode(to_underlying(Fields::kTilt), tilt);
+ encoder.Encode(to_underlying(Fields::kZoom), zoom);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPan))
+ {
+ err = DataModel::Decode(reader, pan);
+ }
+ else if (__context_tag == to_underlying(Fields::kTilt))
+ {
+ err = DataModel::Decode(reader, tilt);
+ }
+ else if (__context_tag == to_underlying(Fields::kZoom))
+ {
+ err = DataModel::Decode(reader, zoom);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MPTZStruct
+
+namespace MPTZPresetStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetID), presetID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ encoder.Encode(to_underlying(Fields::kSettings), settings);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetID))
+ {
+ err = DataModel::Decode(reader, presetID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else if (__context_tag == to_underlying(Fields::kSettings))
+ {
+ err = DataModel::Decode(reader, settings);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace MPTZPresetStruct
+} // namespace Structs
+
+namespace Commands {
+namespace MPTZSetPosition {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPan), pan);
+ encoder.Encode(to_underlying(Fields::kTilt), tilt);
+ encoder.Encode(to_underlying(Fields::kZoom), zoom);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPan))
+ {
+ err = DataModel::Decode(reader, pan);
+ }
+ else if (__context_tag == to_underlying(Fields::kTilt))
+ {
+ err = DataModel::Decode(reader, tilt);
+ }
+ else if (__context_tag == to_underlying(Fields::kZoom))
+ {
+ err = DataModel::Decode(reader, zoom);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MPTZSetPosition.
+namespace MPTZRelativeMove {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPanDelta), panDelta);
+ encoder.Encode(to_underlying(Fields::kTiltDelta), tiltDelta);
+ encoder.Encode(to_underlying(Fields::kZoomDelta), zoomDelta);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPanDelta))
+ {
+ err = DataModel::Decode(reader, panDelta);
+ }
+ else if (__context_tag == to_underlying(Fields::kTiltDelta))
+ {
+ err = DataModel::Decode(reader, tiltDelta);
+ }
+ else if (__context_tag == to_underlying(Fields::kZoomDelta))
+ {
+ err = DataModel::Decode(reader, zoomDelta);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MPTZRelativeMove.
+namespace MPTZMoveToPreset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetID), presetID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetID))
+ {
+ err = DataModel::Decode(reader, presetID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MPTZMoveToPreset.
+namespace MPTZSavePreset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetID), presetID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetID))
+ {
+ err = DataModel::Decode(reader, presetID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MPTZSavePreset.
+namespace MPTZRemovePreset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPresetID), presetID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPresetID))
+ {
+ err = DataModel::Decode(reader, presetID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace MPTZRemovePreset.
+namespace DPTZSetViewport {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kViewport), viewport);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kViewport))
+ {
+ err = DataModel::Decode(reader, viewport);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DPTZSetViewport.
+namespace DPTZRelativeMove {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kDeltaX), deltaX);
+ encoder.Encode(to_underlying(Fields::kDeltaY), deltaY);
+ encoder.Encode(to_underlying(Fields::kZoomDelta), zoomDelta);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeltaX))
+ {
+ err = DataModel::Decode(reader, deltaX);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeltaY))
+ {
+ err = DataModel::Decode(reader, deltaY);
+ }
+ else if (__context_tag == to_underlying(Fields::kZoomDelta))
+ {
+ err = DataModel::Decode(reader, zoomDelta);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace DPTZRelativeMove.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::MPTZPosition::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, MPTZPosition);
+ case Attributes::MaxPresets::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, maxPresets);
+ case Attributes::MPTZPresets::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, MPTZPresets);
+ case Attributes::DPTZRelativeMove::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, DPTZRelativeMove);
+ case Attributes::ZoomMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, zoomMax);
+ case Attributes::TiltMin::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tiltMin);
+ case Attributes::TiltMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, tiltMax);
+ case Attributes::PanMin::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, panMin);
+ case Attributes::PanMax::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, panMax);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace CameraAvSettingsUserLevelManagement
+namespace WebRTCTransportProvider {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace SolicitOffer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ encoder.Encode(to_underlying(Fields::kICEServers), ICEServers);
+ encoder.Encode(to_underlying(Fields::kICETransportPolicy), ICETransportPolicy);
+ encoder.Encode(to_underlying(Fields::kMetadataOptions), metadataOptions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kICEServers))
+ {
+ err = DataModel::Decode(reader, ICEServers);
+ }
+ else if (__context_tag == to_underlying(Fields::kICETransportPolicy))
+ {
+ err = DataModel::Decode(reader, ICETransportPolicy);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetadataOptions))
+ {
+ err = DataModel::Decode(reader, metadataOptions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SolicitOffer.
+namespace SolicitOfferResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kDeferredOffer), deferredOffer);
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeferredOffer))
+ {
+ err = DataModel::Decode(reader, deferredOffer);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SolicitOfferResponse.
+namespace ProvideOffer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kSdp), sdp);
+ encoder.Encode(to_underlying(Fields::kStreamUsage), streamUsage);
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ encoder.Encode(to_underlying(Fields::kICEServers), ICEServers);
+ encoder.Encode(to_underlying(Fields::kICETransportPolicy), ICETransportPolicy);
+ encoder.Encode(to_underlying(Fields::kMetadataOptions), metadataOptions);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSdp))
+ {
+ err = DataModel::Decode(reader, sdp);
+ }
+ else if (__context_tag == to_underlying(Fields::kStreamUsage))
+ {
+ err = DataModel::Decode(reader, streamUsage);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kICEServers))
+ {
+ err = DataModel::Decode(reader, ICEServers);
+ }
+ else if (__context_tag == to_underlying(Fields::kICETransportPolicy))
+ {
+ err = DataModel::Decode(reader, ICETransportPolicy);
+ }
+ else if (__context_tag == to_underlying(Fields::kMetadataOptions))
+ {
+ err = DataModel::Decode(reader, metadataOptions);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ProvideOffer.
+namespace ProvideOfferResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
+ encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kVideoStreamID))
+ {
+ err = DataModel::Decode(reader, videoStreamID);
+ }
+ else if (__context_tag == to_underlying(Fields::kAudioStreamID))
+ {
+ err = DataModel::Decode(reader, audioStreamID);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ProvideOfferResponse.
+namespace ProvideAnswer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kSdp), sdp);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSdp))
+ {
+ err = DataModel::Decode(reader, sdp);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ProvideAnswer.
+namespace ProvideICECandidate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kICECandidate), ICECandidate);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kICECandidate))
+ {
+ err = DataModel::Decode(reader, ICECandidate);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ProvideICECandidate.
+namespace EndSession {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kReason), reason);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kReason))
+ {
+ err = DataModel::Decode(reader, reason);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace EndSession.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CurrentSessions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentSessions);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace WebRTCTransportProvider
+namespace WebRTCTransportRequestor {
+namespace Structs {} // namespace Structs
+
+namespace Commands {
+namespace Offer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kSdp), sdp);
+ encoder.Encode(to_underlying(Fields::kICEServers), ICEServers);
+ encoder.Encode(to_underlying(Fields::kICETransportPolicy), ICETransportPolicy);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSdp))
+ {
+ err = DataModel::Decode(reader, sdp);
+ }
+ else if (__context_tag == to_underlying(Fields::kICEServers))
+ {
+ err = DataModel::Decode(reader, ICEServers);
+ }
+ else if (__context_tag == to_underlying(Fields::kICETransportPolicy))
+ {
+ err = DataModel::Decode(reader, ICETransportPolicy);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Offer.
+namespace Answer {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kSdp), sdp);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kSdp))
+ {
+ err = DataModel::Decode(reader, sdp);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace Answer.
+namespace ICECandidate {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kICECandidate), ICECandidate);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kICECandidate))
+ {
+ err = DataModel::Decode(reader, ICECandidate);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ICECandidate.
+namespace End {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
+ encoder.Encode(to_underlying(Fields::kReason), reason);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
+ {
+ err = DataModel::Decode(reader, webRTCSessionID);
+ }
+ else if (__context_tag == to_underlying(Fields::kReason))
+ {
+ err = DataModel::Decode(reader, reason);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace End.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::CurrentSessions::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, currentSessions);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace WebRTCTransportRequestor
+namespace Chime {
+namespace Structs {
+
+namespace ChimeSoundStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kChimeID), chimeID);
+ encoder.Encode(to_underlying(Fields::kName), name);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kChimeID))
+ {
+ err = DataModel::Decode(reader, chimeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kName))
+ {
+ err = DataModel::Decode(reader, name);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace ChimeSoundStruct
+} // namespace Structs
+
+namespace Commands {
+namespace PlayChimeSound {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace PlayChimeSound.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::InstalledChimeSounds::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, installedChimeSounds);
+ case Attributes::ActiveChimeID::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, activeChimeID);
+ case Attributes::Enabled::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enabled);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace Chime
+namespace EcosystemInformation {
+namespace Structs {
+
+namespace EcosystemDeviceStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kDeviceName), deviceName);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kDeviceNameLastEdit), deviceNameLastEdit);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kBridgedEndpoint), bridgedEndpoint);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kOriginalEndpoint), originalEndpoint);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kDeviceTypes), deviceTypes);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kUniqueLocationIDs), uniqueLocationIDs);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kUniqueLocationIDsLastEdit), uniqueLocationIDsLastEdit);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kDeviceName))
+ {
+ err = DataModel::Decode(reader, deviceName);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeviceNameLastEdit))
+ {
+ err = DataModel::Decode(reader, deviceNameLastEdit);
+ }
+ else if (__context_tag == to_underlying(Fields::kBridgedEndpoint))
+ {
+ err = DataModel::Decode(reader, bridgedEndpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kOriginalEndpoint))
+ {
+ err = DataModel::Decode(reader, originalEndpoint);
+ }
+ else if (__context_tag == to_underlying(Fields::kDeviceTypes))
+ {
+ err = DataModel::Decode(reader, deviceTypes);
+ }
+ else if (__context_tag == to_underlying(Fields::kUniqueLocationIDs))
+ {
+ err = DataModel::Decode(reader, uniqueLocationIDs);
+ }
+ else if (__context_tag == to_underlying(Fields::kUniqueLocationIDsLastEdit))
+ {
+ err = DataModel::Decode(reader, uniqueLocationIDsLastEdit);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace EcosystemDeviceStruct
+
+namespace EcosystemLocationStruct {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kUniqueLocationID), uniqueLocationID);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kLocationDescriptor), locationDescriptor);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kLocationDescriptorLastEdit), locationDescriptorLastEdit);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kUniqueLocationID))
+ {
+ err = DataModel::Decode(reader, uniqueLocationID);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocationDescriptor))
+ {
+ err = DataModel::Decode(reader, locationDescriptor);
+ }
+ else if (__context_tag == to_underlying(Fields::kLocationDescriptorLastEdit))
+ {
+ err = DataModel::Decode(reader, locationDescriptorLastEdit);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace EcosystemLocationStruct
+} // namespace Structs
+
+namespace Commands {} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::DeviceDirectory::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, deviceDirectory);
+ case Attributes::LocationDirectory::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, locationDirectory);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace EcosystemInformation
+namespace CommissionerControl {
+
+namespace Commands {
+namespace RequestCommissioningApproval {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRequestID), requestID);
+ encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
+ encoder.Encode(to_underlying(Fields::kProductID), productID);
+ encoder.Encode(to_underlying(Fields::kLabel), label);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRequestID))
+ {
+ err = DataModel::Decode(reader, requestID);
+ }
+ else if (__context_tag == to_underlying(Fields::kVendorID))
+ {
+ err = DataModel::Decode(reader, vendorID);
+ }
+ else if (__context_tag == to_underlying(Fields::kProductID))
+ {
+ err = DataModel::Decode(reader, productID);
+ }
+ else if (__context_tag == to_underlying(Fields::kLabel))
+ {
+ err = DataModel::Decode(reader, label);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace RequestCommissioningApproval.
+namespace CommissionNode {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kRequestID), requestID);
+ encoder.Encode(to_underlying(Fields::kResponseTimeoutSeconds), responseTimeoutSeconds);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRequestID))
+ {
+ err = DataModel::Decode(reader, requestID);
+ }
+ else if (__context_tag == to_underlying(Fields::kResponseTimeoutSeconds))
+ {
+ err = DataModel::Decode(reader, responseTimeoutSeconds);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CommissionNode.
+namespace ReverseOpenCommissioningWindow {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kCommissioningTimeout), commissioningTimeout);
+ encoder.Encode(to_underlying(Fields::kPAKEPasscodeVerifier), PAKEPasscodeVerifier);
+ encoder.Encode(to_underlying(Fields::kDiscriminator), discriminator);
+ encoder.Encode(to_underlying(Fields::kIterations), iterations);
+ encoder.Encode(to_underlying(Fields::kSalt), salt);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCommissioningTimeout))
+ {
+ err = DataModel::Decode(reader, commissioningTimeout);
+ }
+ else if (__context_tag == to_underlying(Fields::kPAKEPasscodeVerifier))
+ {
+ err = DataModel::Decode(reader, PAKEPasscodeVerifier);
+ }
+ else if (__context_tag == to_underlying(Fields::kDiscriminator))
+ {
+ err = DataModel::Decode(reader, discriminator);
+ }
+ else if (__context_tag == to_underlying(Fields::kIterations))
+ {
+ err = DataModel::Decode(reader, iterations);
+ }
+ else if (__context_tag == to_underlying(Fields::kSalt))
+ {
+ err = DataModel::Decode(reader, salt);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace ReverseOpenCommissioningWindow.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::SupportedDeviceCategories::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, supportedDeviceCategories);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace CommissioningRequestResult {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kRequestID), requestID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kClientNodeID), clientNodeID));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStatusCode), statusCode));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kRequestID))
+ {
+ err = DataModel::Decode(reader, requestID);
+ }
+ else if (__context_tag == to_underlying(Fields::kClientNodeID))
+ {
+ err = DataModel::Decode(reader, clientNodeID);
+ }
+ else if (__context_tag == to_underlying(Fields::kStatusCode))
+ {
+ err = DataModel::Decode(reader, statusCode);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace CommissioningRequestResult.
+} // namespace Events
+
+} // namespace CommissionerControl
+namespace UnitTesting {
+namespace Structs {
+
+namespace SimpleStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kA), a);
+ encoder.Encode(to_underlying(Fields::kB), b);
+ encoder.Encode(to_underlying(Fields::kC), c);
+ encoder.Encode(to_underlying(Fields::kD), d);
+ encoder.Encode(to_underlying(Fields::kE), e);
+ encoder.Encode(to_underlying(Fields::kF), f);
+ encoder.Encode(to_underlying(Fields::kG), g);
+ encoder.Encode(to_underlying(Fields::kH), h);
+ encoder.Encode(to_underlying(Fields::kI), i);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kA))
+ {
+ err = DataModel::Decode(reader, a);
+ }
+ else if (__context_tag == to_underlying(Fields::kB))
+ {
+ err = DataModel::Decode(reader, b);
+ }
+ else if (__context_tag == to_underlying(Fields::kC))
+ {
+ err = DataModel::Decode(reader, c);
+ }
+ else if (__context_tag == to_underlying(Fields::kD))
+ {
+ err = DataModel::Decode(reader, d);
+ }
+ else if (__context_tag == to_underlying(Fields::kE))
+ {
+ err = DataModel::Decode(reader, e);
+ }
+ else if (__context_tag == to_underlying(Fields::kF))
+ {
+ err = DataModel::Decode(reader, f);
+ }
+ else if (__context_tag == to_underlying(Fields::kG))
+ {
+ err = DataModel::Decode(reader, g);
+ }
+ else if (__context_tag == to_underlying(Fields::kH))
+ {
+ err = DataModel::Decode(reader, h);
+ }
+ else if (__context_tag == to_underlying(Fields::kI))
+ {
+ err = DataModel::Decode(reader, i);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace SimpleStruct
+
+namespace TestFabricScoped {
+CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ return DoEncode(aWriter, aTag, NullOptional);
+}
+
+CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
+{
+ return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
+}
+
+CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
+{
+ bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);
+
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kFabricSensitiveInt8u), fabricSensitiveInt8u);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kOptionalFabricSensitiveInt8u), optionalFabricSensitiveInt8u);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kNullableFabricSensitiveInt8u), nullableFabricSensitiveInt8u);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kNullableOptionalFabricSensitiveInt8u), nullableOptionalFabricSensitiveInt8u);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kFabricSensitiveCharString), fabricSensitiveCharString);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kFabricSensitiveStruct), fabricSensitiveStruct);
+ }
+ if (includeSensitive)
+ {
+ encoder.Encode(to_underlying(Fields::kFabricSensitiveInt8uList), fabricSensitiveInt8uList);
+ }
+ if (aAccessingFabricIndex.HasValue())
+ {
+ encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
+ }
+
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFabricSensitiveInt8u))
+ {
+ err = DataModel::Decode(reader, fabricSensitiveInt8u);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalFabricSensitiveInt8u))
+ {
+ err = DataModel::Decode(reader, optionalFabricSensitiveInt8u);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableFabricSensitiveInt8u))
+ {
+ err = DataModel::Decode(reader, nullableFabricSensitiveInt8u);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalFabricSensitiveInt8u))
+ {
+ err = DataModel::Decode(reader, nullableOptionalFabricSensitiveInt8u);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricSensitiveCharString))
+ {
+ err = DataModel::Decode(reader, fabricSensitiveCharString);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricSensitiveStruct))
+ {
+ err = DataModel::Decode(reader, fabricSensitiveStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricSensitiveInt8uList))
+ {
+ err = DataModel::Decode(reader, fabricSensitiveInt8uList);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TestFabricScoped
+
+namespace NullablesAndOptionalsStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNullableInt), nullableInt);
+ encoder.Encode(to_underlying(Fields::kOptionalInt), optionalInt);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalInt), nullableOptionalInt);
+ encoder.Encode(to_underlying(Fields::kNullableString), nullableString);
+ encoder.Encode(to_underlying(Fields::kOptionalString), optionalString);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalString), nullableOptionalString);
+ encoder.Encode(to_underlying(Fields::kNullableStruct), nullableStruct);
+ encoder.Encode(to_underlying(Fields::kOptionalStruct), optionalStruct);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStruct), nullableOptionalStruct);
+ encoder.Encode(to_underlying(Fields::kNullableList), nullableList);
+ encoder.Encode(to_underlying(Fields::kOptionalList), optionalList);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalList), nullableOptionalList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNullableInt))
+ {
+ err = DataModel::Decode(reader, nullableInt);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalInt))
+ {
+ err = DataModel::Decode(reader, optionalInt);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalInt))
+ {
+ err = DataModel::Decode(reader, nullableOptionalInt);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableString))
+ {
+ err = DataModel::Decode(reader, nullableString);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalString))
+ {
+ err = DataModel::Decode(reader, optionalString);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalString))
+ {
+ err = DataModel::Decode(reader, nullableOptionalString);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableStruct))
+ {
+ err = DataModel::Decode(reader, nullableStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalStruct))
+ {
+ err = DataModel::Decode(reader, optionalStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStruct))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableList))
+ {
+ err = DataModel::Decode(reader, nullableList);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalList))
+ {
+ err = DataModel::Decode(reader, optionalList);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalList))
+ {
+ err = DataModel::Decode(reader, nullableOptionalList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NullablesAndOptionalsStruct
+
+namespace NestedStruct {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kA), a);
+ encoder.Encode(to_underlying(Fields::kB), b);
+ encoder.Encode(to_underlying(Fields::kC), c);
+ encoder.Encode(to_underlying(Fields::kD), d);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kA))
+ {
+ err = DataModel::Decode(reader, a);
+ }
+ else if (__context_tag == to_underlying(Fields::kB))
+ {
+ err = DataModel::Decode(reader, b);
+ }
+ else if (__context_tag == to_underlying(Fields::kC))
+ {
+ err = DataModel::Decode(reader, c);
+ }
+ else if (__context_tag == to_underlying(Fields::kD))
+ {
+ err = DataModel::Decode(reader, d);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NestedStruct
+
+namespace NestedStructList {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kA), a);
+ encoder.Encode(to_underlying(Fields::kB), b);
+ encoder.Encode(to_underlying(Fields::kC), c);
+ encoder.Encode(to_underlying(Fields::kD), d);
+ encoder.Encode(to_underlying(Fields::kE), e);
+ encoder.Encode(to_underlying(Fields::kF), f);
+ encoder.Encode(to_underlying(Fields::kG), g);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kA))
+ {
+ err = DataModel::Decode(reader, a);
+ }
+ else if (__context_tag == to_underlying(Fields::kB))
+ {
+ err = DataModel::Decode(reader, b);
+ }
+ else if (__context_tag == to_underlying(Fields::kC))
+ {
+ err = DataModel::Decode(reader, c);
+ }
+ else if (__context_tag == to_underlying(Fields::kD))
+ {
+ err = DataModel::Decode(reader, d);
+ }
+ else if (__context_tag == to_underlying(Fields::kE))
+ {
+ err = DataModel::Decode(reader, e);
+ }
+ else if (__context_tag == to_underlying(Fields::kF))
+ {
+ err = DataModel::Decode(reader, f);
+ }
+ else if (__context_tag == to_underlying(Fields::kG))
+ {
+ err = DataModel::Decode(reader, g);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace NestedStructList
+
+namespace DoubleNestedStructList {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kA), a);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kA))
+ {
+ err = DataModel::Decode(reader, a);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace DoubleNestedStructList
+
+namespace TestListStructOctet {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kMember1), member1);
+ encoder.Encode(to_underlying(Fields::kMember2), member2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kMember1))
+ {
+ err = DataModel::Decode(reader, member1);
+ }
+ else if (__context_tag == to_underlying(Fields::kMember2))
+ {
+ err = DataModel::Decode(reader, member2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+
+} // namespace TestListStructOctet
+} // namespace Structs
+
+namespace Commands {
+namespace Test {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Test.
+namespace TestSpecificResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReturnValue))
+ {
+ err = DataModel::Decode(reader, returnValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestSpecificResponse.
+namespace TestNotHandled {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TestNotHandled.
+namespace TestAddArgumentsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReturnValue))
+ {
+ err = DataModel::Decode(reader, returnValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestAddArgumentsResponse.
+namespace TestSpecific {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TestSpecific.
+namespace TestSimpleArgumentResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReturnValue))
+ {
+ err = DataModel::Decode(reader, returnValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestSimpleArgumentResponse.
+namespace TestUnknownCommand {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TestUnknownCommand.
+namespace TestStructArrayArgumentResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ encoder.Encode(to_underlying(Fields::kArg3), arg3);
+ encoder.Encode(to_underlying(Fields::kArg4), arg4);
+ encoder.Encode(to_underlying(Fields::kArg5), arg5);
+ encoder.Encode(to_underlying(Fields::kArg6), arg6);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg3))
+ {
+ err = DataModel::Decode(reader, arg3);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg4))
+ {
+ err = DataModel::Decode(reader, arg4);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg5))
+ {
+ err = DataModel::Decode(reader, arg5);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg6))
+ {
+ err = DataModel::Decode(reader, arg6);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestStructArrayArgumentResponse.
+namespace TestAddArguments {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestAddArguments.
+namespace TestListInt8UReverseResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestListInt8UReverseResponse.
+namespace TestSimpleArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestSimpleArgumentRequest.
+namespace TestEnumsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEnumsResponse.
+namespace TestStructArrayArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ encoder.Encode(to_underlying(Fields::kArg3), arg3);
+ encoder.Encode(to_underlying(Fields::kArg4), arg4);
+ encoder.Encode(to_underlying(Fields::kArg5), arg5);
+ encoder.Encode(to_underlying(Fields::kArg6), arg6);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg3))
+ {
+ err = DataModel::Decode(reader, arg3);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg4))
+ {
+ err = DataModel::Decode(reader, arg4);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg5))
+ {
+ err = DataModel::Decode(reader, arg5);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg6))
+ {
+ err = DataModel::Decode(reader, arg6);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestStructArrayArgumentRequest.
+namespace TestNullableOptionalResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kWasPresent), wasPresent);
+ encoder.Encode(to_underlying(Fields::kWasNull), wasNull);
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ encoder.Encode(to_underlying(Fields::kOriginalValue), originalValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kWasPresent))
+ {
+ err = DataModel::Decode(reader, wasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kWasNull))
+ {
+ err = DataModel::Decode(reader, wasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else if (__context_tag == to_underlying(Fields::kOriginalValue))
+ {
+ err = DataModel::Decode(reader, originalValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestNullableOptionalResponse.
+namespace TestStructArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestStructArgumentRequest.
+namespace TestComplexNullableOptionalResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNullableIntWasNull), nullableIntWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableIntValue), nullableIntValue);
+ encoder.Encode(to_underlying(Fields::kOptionalIntWasPresent), optionalIntWasPresent);
+ encoder.Encode(to_underlying(Fields::kOptionalIntValue), optionalIntValue);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalIntWasPresent), nullableOptionalIntWasPresent);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalIntWasNull), nullableOptionalIntWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalIntValue), nullableOptionalIntValue);
+ encoder.Encode(to_underlying(Fields::kNullableStringWasNull), nullableStringWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableStringValue), nullableStringValue);
+ encoder.Encode(to_underlying(Fields::kOptionalStringWasPresent), optionalStringWasPresent);
+ encoder.Encode(to_underlying(Fields::kOptionalStringValue), optionalStringValue);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStringWasPresent), nullableOptionalStringWasPresent);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStringWasNull), nullableOptionalStringWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStringValue), nullableOptionalStringValue);
+ encoder.Encode(to_underlying(Fields::kNullableStructWasNull), nullableStructWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableStructValue), nullableStructValue);
+ encoder.Encode(to_underlying(Fields::kOptionalStructWasPresent), optionalStructWasPresent);
+ encoder.Encode(to_underlying(Fields::kOptionalStructValue), optionalStructValue);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStructWasPresent), nullableOptionalStructWasPresent);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStructWasNull), nullableOptionalStructWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStructValue), nullableOptionalStructValue);
+ encoder.Encode(to_underlying(Fields::kNullableListWasNull), nullableListWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableListValue), nullableListValue);
+ encoder.Encode(to_underlying(Fields::kOptionalListWasPresent), optionalListWasPresent);
+ encoder.Encode(to_underlying(Fields::kOptionalListValue), optionalListValue);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalListWasPresent), nullableOptionalListWasPresent);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalListWasNull), nullableOptionalListWasNull);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalListValue), nullableOptionalListValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNullableIntWasNull))
+ {
+ err = DataModel::Decode(reader, nullableIntWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableIntValue))
+ {
+ err = DataModel::Decode(reader, nullableIntValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalIntWasPresent))
+ {
+ err = DataModel::Decode(reader, optionalIntWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalIntValue))
+ {
+ err = DataModel::Decode(reader, optionalIntValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalIntWasPresent))
+ {
+ err = DataModel::Decode(reader, nullableOptionalIntWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalIntWasNull))
+ {
+ err = DataModel::Decode(reader, nullableOptionalIntWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalIntValue))
+ {
+ err = DataModel::Decode(reader, nullableOptionalIntValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableStringWasNull))
+ {
+ err = DataModel::Decode(reader, nullableStringWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableStringValue))
+ {
+ err = DataModel::Decode(reader, nullableStringValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalStringWasPresent))
+ {
+ err = DataModel::Decode(reader, optionalStringWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalStringValue))
+ {
+ err = DataModel::Decode(reader, optionalStringValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStringWasPresent))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStringWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStringWasNull))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStringWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStringValue))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStringValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableStructWasNull))
+ {
+ err = DataModel::Decode(reader, nullableStructWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableStructValue))
+ {
+ err = DataModel::Decode(reader, nullableStructValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalStructWasPresent))
+ {
+ err = DataModel::Decode(reader, optionalStructWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalStructValue))
+ {
+ err = DataModel::Decode(reader, optionalStructValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStructWasPresent))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStructWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStructWasNull))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStructWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStructValue))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStructValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableListWasNull))
+ {
+ err = DataModel::Decode(reader, nullableListWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableListValue))
+ {
+ err = DataModel::Decode(reader, nullableListValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalListWasPresent))
+ {
+ err = DataModel::Decode(reader, optionalListWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalListValue))
+ {
+ err = DataModel::Decode(reader, optionalListValue);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalListWasPresent))
+ {
+ err = DataModel::Decode(reader, nullableOptionalListWasPresent);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalListWasNull))
+ {
+ err = DataModel::Decode(reader, nullableOptionalListWasNull);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalListValue))
+ {
+ err = DataModel::Decode(reader, nullableOptionalListValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestComplexNullableOptionalResponse.
+namespace TestNestedStructArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestNestedStructArgumentRequest.
+namespace BooleanResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace BooleanResponse.
+namespace TestListStructArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestListStructArgumentRequest.
+namespace SimpleStructResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SimpleStructResponse.
+namespace TestListInt8UArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestListInt8UArgumentRequest.
+namespace TestEmitTestEventResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEmitTestEventResponse.
+namespace TestNestedStructListArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestNestedStructListArgumentRequest.
+namespace TestEmitTestFabricScopedEventResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kValue), value);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kValue))
+ {
+ err = DataModel::Decode(reader, value);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEmitTestFabricScopedEventResponse.
+namespace TestListNestedStructListArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestListNestedStructListArgumentRequest.
+namespace TestBatchHelperResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kBuffer), buffer);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kBuffer))
+ {
+ err = DataModel::Decode(reader, buffer);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestBatchHelperResponse.
+namespace TestListInt8UReverseRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestListInt8UReverseRequest.
+namespace StringEchoResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPayload), payload);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPayload))
+ {
+ err = DataModel::Decode(reader, payload);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StringEchoResponse.
+namespace TestEnumsRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEnumsRequest.
+namespace GlobalEchoResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kField1), field1);
+ encoder.Encode(to_underlying(Fields::kField2), field2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kField1))
+ {
+ err = DataModel::Decode(reader, field1);
+ }
+ else if (__context_tag == to_underlying(Fields::kField2))
+ {
+ err = DataModel::Decode(reader, field2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GlobalEchoResponse.
+namespace TestNullableOptionalRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestNullableOptionalRequest.
+namespace TestComplexNullableOptionalRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kNullableInt), nullableInt);
+ encoder.Encode(to_underlying(Fields::kOptionalInt), optionalInt);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalInt), nullableOptionalInt);
+ encoder.Encode(to_underlying(Fields::kNullableString), nullableString);
+ encoder.Encode(to_underlying(Fields::kOptionalString), optionalString);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalString), nullableOptionalString);
+ encoder.Encode(to_underlying(Fields::kNullableStruct), nullableStruct);
+ encoder.Encode(to_underlying(Fields::kOptionalStruct), optionalStruct);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalStruct), nullableOptionalStruct);
+ encoder.Encode(to_underlying(Fields::kNullableList), nullableList);
+ encoder.Encode(to_underlying(Fields::kOptionalList), optionalList);
+ encoder.Encode(to_underlying(Fields::kNullableOptionalList), nullableOptionalList);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kNullableInt))
+ {
+ err = DataModel::Decode(reader, nullableInt);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalInt))
+ {
+ err = DataModel::Decode(reader, optionalInt);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalInt))
+ {
+ err = DataModel::Decode(reader, nullableOptionalInt);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableString))
+ {
+ err = DataModel::Decode(reader, nullableString);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalString))
+ {
+ err = DataModel::Decode(reader, optionalString);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalString))
+ {
+ err = DataModel::Decode(reader, nullableOptionalString);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableStruct))
+ {
+ err = DataModel::Decode(reader, nullableStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalStruct))
+ {
+ err = DataModel::Decode(reader, optionalStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalStruct))
+ {
+ err = DataModel::Decode(reader, nullableOptionalStruct);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableList))
+ {
+ err = DataModel::Decode(reader, nullableList);
+ }
+ else if (__context_tag == to_underlying(Fields::kOptionalList))
+ {
+ err = DataModel::Decode(reader, optionalList);
+ }
+ else if (__context_tag == to_underlying(Fields::kNullableOptionalList))
+ {
+ err = DataModel::Decode(reader, nullableOptionalList);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestComplexNullableOptionalRequest.
+namespace SimpleStructEchoRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace SimpleStructEchoRequest.
+namespace TimedInvokeRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace TimedInvokeRequest.
+namespace TestSimpleOptionalArgumentRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestSimpleOptionalArgumentRequest.
+namespace TestEmitTestEventRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ encoder.Encode(to_underlying(Fields::kArg3), arg3);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg3))
+ {
+ err = DataModel::Decode(reader, arg3);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEmitTestEventRequest.
+namespace TestEmitTestFabricScopedEventRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEmitTestFabricScopedEventRequest.
+namespace TestBatchHelperRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSleepBeforeResponseTimeMs), sleepBeforeResponseTimeMs);
+ encoder.Encode(to_underlying(Fields::kSizeOfResponseBuffer), sizeOfResponseBuffer);
+ encoder.Encode(to_underlying(Fields::kFillCharacter), fillCharacter);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSleepBeforeResponseTimeMs))
+ {
+ err = DataModel::Decode(reader, sleepBeforeResponseTimeMs);
+ }
+ else if (__context_tag == to_underlying(Fields::kSizeOfResponseBuffer))
+ {
+ err = DataModel::Decode(reader, sizeOfResponseBuffer);
+ }
+ else if (__context_tag == to_underlying(Fields::kFillCharacter))
+ {
+ err = DataModel::Decode(reader, fillCharacter);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestBatchHelperRequest.
+namespace TestSecondBatchHelperRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kSleepBeforeResponseTimeMs), sleepBeforeResponseTimeMs);
+ encoder.Encode(to_underlying(Fields::kSizeOfResponseBuffer), sizeOfResponseBuffer);
+ encoder.Encode(to_underlying(Fields::kFillCharacter), fillCharacter);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kSleepBeforeResponseTimeMs))
+ {
+ err = DataModel::Decode(reader, sleepBeforeResponseTimeMs);
+ }
+ else if (__context_tag == to_underlying(Fields::kSizeOfResponseBuffer))
+ {
+ err = DataModel::Decode(reader, sizeOfResponseBuffer);
+ }
+ else if (__context_tag == to_underlying(Fields::kFillCharacter))
+ {
+ err = DataModel::Decode(reader, fillCharacter);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestSecondBatchHelperRequest.
+namespace StringEchoRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kPayload), payload);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kPayload))
+ {
+ err = DataModel::Decode(reader, payload);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace StringEchoRequest.
+namespace GlobalEchoRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kField1), field1);
+ encoder.Encode(to_underlying(Fields::kField2), field2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kField1))
+ {
+ err = DataModel::Decode(reader, field1);
+ }
+ else if (__context_tag == to_underlying(Fields::kField2))
+ {
+ err = DataModel::Decode(reader, field2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace GlobalEchoRequest.
+namespace TestDifferentVendorMeiRequest {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestDifferentVendorMeiRequest.
+namespace TestDifferentVendorMeiResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kEventNumber), eventNumber);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kEventNumber))
+ {
+ err = DataModel::Decode(reader, eventNumber);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestDifferentVendorMeiResponse.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Boolean::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, boolean);
+ case Attributes::Bitmap8::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, bitmap8);
+ case Attributes::Bitmap16::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, bitmap16);
+ case Attributes::Bitmap32::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, bitmap32);
+ case Attributes::Bitmap64::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, bitmap64);
+ case Attributes::Int8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int8u);
+ case Attributes::Int16u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int16u);
+ case Attributes::Int24u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int24u);
+ case Attributes::Int32u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int32u);
+ case Attributes::Int40u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int40u);
+ case Attributes::Int48u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int48u);
+ case Attributes::Int56u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int56u);
+ case Attributes::Int64u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int64u);
+ case Attributes::Int8s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int8s);
+ case Attributes::Int16s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int16s);
+ case Attributes::Int24s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int24s);
+ case Attributes::Int32s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int32s);
+ case Attributes::Int40s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int40s);
+ case Attributes::Int48s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int48s);
+ case Attributes::Int56s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int56s);
+ case Attributes::Int64s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, int64s);
+ case Attributes::Enum8::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enum8);
+ case Attributes::Enum16::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enum16);
+ case Attributes::FloatSingle::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, floatSingle);
+ case Attributes::FloatDouble::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, floatDouble);
+ case Attributes::OctetString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, octetString);
+ case Attributes::ListInt8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, listInt8u);
+ case Attributes::ListOctetString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, listOctetString);
+ case Attributes::ListStructOctetString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, listStructOctetString);
+ case Attributes::LongOctetString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, longOctetString);
+ case Attributes::CharString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, charString);
+ case Attributes::LongCharString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, longCharString);
+ case Attributes::EpochUs::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, epochUs);
+ case Attributes::EpochS::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, epochS);
+ case Attributes::VendorId::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, vendorId);
+ case Attributes::ListNullablesAndOptionalsStruct::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, listNullablesAndOptionalsStruct);
+ case Attributes::EnumAttr::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, enumAttr);
+ case Attributes::StructAttr::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, structAttr);
+ case Attributes::RangeRestrictedInt8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rangeRestrictedInt8u);
+ case Attributes::RangeRestrictedInt8s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rangeRestrictedInt8s);
+ case Attributes::RangeRestrictedInt16u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rangeRestrictedInt16u);
+ case Attributes::RangeRestrictedInt16s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, rangeRestrictedInt16s);
+ case Attributes::ListLongOctetString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, listLongOctetString);
+ case Attributes::ListFabricScoped::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, listFabricScoped);
+ case Attributes::TimedWriteBoolean::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, timedWriteBoolean);
+ case Attributes::GeneralErrorBoolean::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generalErrorBoolean);
+ case Attributes::ClusterErrorBoolean::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterErrorBoolean);
+ case Attributes::GlobalEnum::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, globalEnum);
+ case Attributes::GlobalStruct::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, globalStruct);
+ case Attributes::Unsupported::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, unsupported);
+ case Attributes::ReadFailureCode::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, readFailureCode);
+ case Attributes::FailureInt32U::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, failureInt32U);
+ case Attributes::NullableBoolean::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableBoolean);
+ case Attributes::NullableBitmap8::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableBitmap8);
+ case Attributes::NullableBitmap16::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableBitmap16);
+ case Attributes::NullableBitmap32::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableBitmap32);
+ case Attributes::NullableBitmap64::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableBitmap64);
+ case Attributes::NullableInt8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt8u);
+ case Attributes::NullableInt16u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt16u);
+ case Attributes::NullableInt24u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt24u);
+ case Attributes::NullableInt32u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt32u);
+ case Attributes::NullableInt40u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt40u);
+ case Attributes::NullableInt48u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt48u);
+ case Attributes::NullableInt56u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt56u);
+ case Attributes::NullableInt64u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt64u);
+ case Attributes::NullableInt8s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt8s);
+ case Attributes::NullableInt16s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt16s);
+ case Attributes::NullableInt24s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt24s);
+ case Attributes::NullableInt32s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt32s);
+ case Attributes::NullableInt40s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt40s);
+ case Attributes::NullableInt48s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt48s);
+ case Attributes::NullableInt56s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt56s);
+ case Attributes::NullableInt64s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableInt64s);
+ case Attributes::NullableEnum8::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableEnum8);
+ case Attributes::NullableEnum16::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableEnum16);
+ case Attributes::NullableFloatSingle::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableFloatSingle);
+ case Attributes::NullableFloatDouble::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableFloatDouble);
+ case Attributes::NullableOctetString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableOctetString);
+ case Attributes::NullableCharString::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableCharString);
+ case Attributes::NullableEnumAttr::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableEnumAttr);
+ case Attributes::NullableStruct::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableStruct);
+ case Attributes::NullableRangeRestrictedInt8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableRangeRestrictedInt8u);
+ case Attributes::NullableRangeRestrictedInt8s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableRangeRestrictedInt8s);
+ case Attributes::NullableRangeRestrictedInt16u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableRangeRestrictedInt16u);
+ case Attributes::NullableRangeRestrictedInt16s::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableRangeRestrictedInt16s);
+ case Attributes::WriteOnlyInt8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, writeOnlyInt8u);
+ case Attributes::NullableGlobalEnum::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableGlobalEnum);
+ case Attributes::NullableGlobalStruct::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, nullableGlobalStruct);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ case Attributes::MeiInt8u::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, meiInt8u);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace TestEvent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg1), arg1));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg2), arg2));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg3), arg3));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg4), arg4));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg5), arg5));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg6), arg6));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg3))
+ {
+ err = DataModel::Decode(reader, arg3);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg4))
+ {
+ err = DataModel::Decode(reader, arg4);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg5))
+ {
+ err = DataModel::Decode(reader, arg5);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg6))
+ {
+ err = DataModel::Decode(reader, arg6);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestEvent.
+namespace TestFabricScopedEvent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestFabricScopedEvent.
+namespace TestDifferentVendorMeiEvent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg1), arg1));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace TestDifferentVendorMeiEvent.
+} // namespace Events
+
+} // namespace UnitTesting
+namespace FaultInjection {
+
+namespace Commands {
+namespace FailAtFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kType), type);
+ encoder.Encode(to_underlying(Fields::kId), id);
+ encoder.Encode(to_underlying(Fields::kNumCallsToSkip), numCallsToSkip);
+ encoder.Encode(to_underlying(Fields::kNumCallsToFail), numCallsToFail);
+ encoder.Encode(to_underlying(Fields::kTakeMutex), takeMutex);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else if (__context_tag == to_underlying(Fields::kNumCallsToSkip))
+ {
+ err = DataModel::Decode(reader, numCallsToSkip);
+ }
+ else if (__context_tag == to_underlying(Fields::kNumCallsToFail))
+ {
+ err = DataModel::Decode(reader, numCallsToFail);
+ }
+ else if (__context_tag == to_underlying(Fields::kTakeMutex))
+ {
+ err = DataModel::Decode(reader, takeMutex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace FailAtFault.
+namespace FailRandomlyAtFault {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kType), type);
+ encoder.Encode(to_underlying(Fields::kId), id);
+ encoder.Encode(to_underlying(Fields::kPercentage), percentage);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kType))
+ {
+ err = DataModel::Decode(reader, type);
+ }
+ else if (__context_tag == to_underlying(Fields::kId))
+ {
+ err = DataModel::Decode(reader, id);
+ }
+ else if (__context_tag == to_underlying(Fields::kPercentage))
+ {
+ err = DataModel::Decode(reader, percentage);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace FailRandomlyAtFault.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {} // namespace Events
+
+} // namespace FaultInjection
+namespace SampleManufacturerSpecific {
+
+namespace Commands {
+namespace Ping {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Ping.
+namespace AddArgumentsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReturnValue))
+ {
+ err = DataModel::Decode(reader, returnValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddArgumentsResponse.
+namespace AddArguments {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddArguments.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::FlipFlop::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, flipFlop);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace PingCountEvent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCount), count));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCount))
+ {
+ err = DataModel::Decode(reader, count);
+ }
+ else if (__context_tag == to_underlying(Fields::kFabricIndex))
+ {
+ err = DataModel::Decode(reader, fabricIndex);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PingCountEvent.
+} // namespace Events
+
+} // namespace SampleManufacturerSpecific
+namespace SampleExternalManufacturerSpecific {
+
+namespace Commands {
+namespace Ping {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+ }
+}
+} // namespace Ping.
+namespace AddArgumentsResponse {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kReturnValue))
+ {
+ err = DataModel::Decode(reader, returnValue);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddArgumentsResponse.
+namespace AddArguments {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
+ encoder.Encode(to_underlying(Fields::kArg1), arg1);
+ encoder.Encode(to_underlying(Fields::kArg2), arg2);
+ return encoder.Finalize();
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kArg1))
+ {
+ err = DataModel::Decode(reader, arg1);
+ }
+ else if (__context_tag == to_underlying(Fields::kArg2))
+ {
+ err = DataModel::Decode(reader, arg2);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace AddArguments.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::FlipFlop::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, flipFlop);
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, generatedCommandList);
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, acceptedCommandList);
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, attributeList);
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, featureMap);
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ return DataModel::Decode(reader, clusterRevision);
+ default:
+ return CHIP_NO_ERROR;
+ }
+}
+} // namespace Attributes
+
+namespace Events {
+namespace PingCountEvent {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCount), count));
+ return aWriter.EndContainer(outer);
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ detail::StructDecodeIterator __iterator(reader);
+ while (true)
+ {
+ auto __element = __iterator.Next();
+ if (std::holds_alternative<CHIP_ERROR>(__element))
+ {
+ return std::get<CHIP_ERROR>(__element);
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ const uint8_t __context_tag = std::get<uint8_t>(__element);
+
+ if (__context_tag == to_underlying(Fields::kCount))
+ {
+ err = DataModel::Decode(reader, count);
+ }
+ else
+ {
+ }
+
+ ReturnErrorOnFailure(err);
+ }
+}
+} // namespace PingCountEvent.
+} // namespace Events
+
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+
+bool CommandNeedsTimedInvoke(ClusterId aCluster, CommandId aCommand)
+{
+ // Maybe it would be smaller code to codegen a table and walk over it?
+ // Not sure.
+ switch (aCluster)
+ {
+ case Clusters::AdministratorCommissioning::Id: {
+ switch (aCommand)
+ {
+ case Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Id:
+ case Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id:
+ case Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::EnergyEvse::Id: {
+ switch (aCommand)
+ {
+ case Clusters::EnergyEvse::Commands::Disable::Id:
+ case Clusters::EnergyEvse::Commands::EnableCharging::Id:
+ case Clusters::EnergyEvse::Commands::EnableDischarging::Id:
+ case Clusters::EnergyEvse::Commands::StartDiagnostics::Id:
+ case Clusters::EnergyEvse::Commands::SetTargets::Id:
+ case Clusters::EnergyEvse::Commands::GetTargets::Id:
+ case Clusters::EnergyEvse::Commands::ClearTargets::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::DoorLock::Id: {
+ switch (aCommand)
+ {
+ case Clusters::DoorLock::Commands::LockDoor::Id:
+ case Clusters::DoorLock::Commands::UnlockDoor::Id:
+ case Clusters::DoorLock::Commands::UnlockWithTimeout::Id:
+ case Clusters::DoorLock::Commands::SetUser::Id:
+ case Clusters::DoorLock::Commands::ClearUser::Id:
+ case Clusters::DoorLock::Commands::SetCredential::Id:
+ case Clusters::DoorLock::Commands::ClearCredential::Id:
+ case Clusters::DoorLock::Commands::UnboltDoor::Id:
+ case Clusters::DoorLock::Commands::SetAliroReaderConfig::Id:
+ case Clusters::DoorLock::Commands::ClearAliroReaderConfig::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::ThreadNetworkDirectory::Id: {
+ switch (aCommand)
+ {
+ case Clusters::ThreadNetworkDirectory::Commands::AddNetwork::Id:
+ case Clusters::ThreadNetworkDirectory::Commands::RemoveNetwork::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::AccountLogin::Id: {
+ switch (aCommand)
+ {
+ case Clusters::AccountLogin::Commands::GetSetupPIN::Id:
+ case Clusters::AccountLogin::Commands::Login::Id:
+ case Clusters::AccountLogin::Commands::Logout::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::UnitTesting::Id: {
+ switch (aCommand)
+ {
+ case Clusters::UnitTesting::Commands::TimedInvokeRequest::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ default:
+ break;
+ }
+
+ return false;
+}
+
+bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand)
+{
+ // Maybe it would be smaller code to codegen a table and walk over it?
+ // Not sure.
+ switch (aCluster)
+ {
+ case Clusters::Identify::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::Groups::Id: {
+ switch (aCommand)
+ {
+ case Clusters::Groups::Commands::AddGroup::Id:
+ return true;
+ case Clusters::Groups::Commands::ViewGroup::Id:
+ return true;
+ case Clusters::Groups::Commands::GetGroupMembership::Id:
+ return true;
+ case Clusters::Groups::Commands::RemoveGroup::Id:
+ return true;
+ case Clusters::Groups::Commands::RemoveAllGroups::Id:
+ return true;
+ case Clusters::Groups::Commands::AddGroupIfIdentifying::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::OnOff::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::LevelControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::AccessControl::Id: {
+ switch (aCommand)
+ {
+ case Clusters::AccessControl::Commands::ReviewFabricRestrictions::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::Actions::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::BasicInformation::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::OtaSoftwareUpdateProvider::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::OtaSoftwareUpdateRequestor::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::GeneralCommissioning::Id: {
+ switch (aCommand)
+ {
+ case Clusters::GeneralCommissioning::Commands::CommissioningComplete::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::NetworkCommissioning::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::DiagnosticLogs::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::GeneralDiagnostics::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::SoftwareDiagnostics::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ThreadNetworkDiagnostics::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WiFiNetworkDiagnostics::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::EthernetNetworkDiagnostics::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::TimeSynchronization::Id: {
+ switch (aCommand)
+ {
+ case Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::BridgedDeviceBasicInformation::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::AdministratorCommissioning::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::OperationalCredentials::Id: {
+ switch (aCommand)
+ {
+ case Clusters::OperationalCredentials::Commands::UpdateNOC::Id:
+ return true;
+ case Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::GroupKeyManagement::Id: {
+ switch (aCommand)
+ {
+ case Clusters::GroupKeyManagement::Commands::KeySetWrite::Id:
+ return true;
+ case Clusters::GroupKeyManagement::Commands::KeySetRead::Id:
+ return true;
+ case Clusters::GroupKeyManagement::Commands::KeySetRemove::Id:
+ return true;
+ case Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::IcdManagement::Id: {
+ switch (aCommand)
+ {
+ case Clusters::IcdManagement::Commands::RegisterClient::Id:
+ return true;
+ case Clusters::IcdManagement::Commands::UnregisterClient::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::Timer::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::OvenCavityOperationalState::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::OvenMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ModeSelect::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::LaundryWasherMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::RvcRunMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::RvcCleanMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::TemperatureControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::DishwasherMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::SmokeCoAlarm::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::DishwasherAlarm::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::MicrowaveOvenControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::OperationalState::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::RvcOperationalState::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ScenesManagement::Id: {
+ switch (aCommand)
+ {
+ case Clusters::ScenesManagement::Commands::AddScene::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::ViewScene::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::RemoveScene::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::RemoveAllScenes::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::StoreScene::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::RecallScene::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::GetSceneMembership::Id:
+ return true;
+ case Clusters::ScenesManagement::Commands::CopyScene::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::HepaFilterMonitoring::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ActivatedCarbonFilterMonitoring::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::BooleanStateConfiguration::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ValveConfigurationAndControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WaterHeaterManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::DemandResponseLoadControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::Messages::Id: {
+ switch (aCommand)
+ {
+ case Clusters::Messages::Commands::PresentMessagesRequest::Id:
+ return true;
+ case Clusters::Messages::Commands::CancelMessagesRequest::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::DeviceEnergyManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::EnergyEvse::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::EnergyEvseMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WaterHeaterMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::DeviceEnergyManagementMode::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::DoorLock::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WindowCovering::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ServiceArea::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::Thermostat::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::FanControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ColorControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WiFiNetworkManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ThreadBorderRouterManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ThreadNetworkDirectory::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::Channel::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::TargetNavigator::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::MediaPlayback::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::MediaInput::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::LowPower::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::KeypadInput::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ContentLauncher::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::AudioOutput::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ApplicationLauncher::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::AccountLogin::Id: {
+ switch (aCommand)
+ {
+ case Clusters::AccountLogin::Commands::GetSetupPIN::Id:
+ return true;
+ case Clusters::AccountLogin::Commands::Login::Id:
+ return true;
+ case Clusters::AccountLogin::Commands::Logout::Id:
+ return true;
+ default:
+ return false;
+ }
+ }
+ case Clusters::ContentControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ContentAppObserver::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::ZoneManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::CameraAvStreamManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::CameraAvSettingsUserLevelManagement::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WebRTCTransportProvider::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::WebRTCTransportRequestor::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::Chime::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::CommissionerControl::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::UnitTesting::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::FaultInjection::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::SampleManufacturerSpecific::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ case Clusters::SampleExternalManufacturerSpecific::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
+ }
+ return false;
+}
+
+bool CommandHasLargePayload(ClusterId aCluster, CommandId aCommand)
+{
+ if ((aCluster == Clusters::CameraAvStreamManagement::Id) &&
+ (aCommand == Clusters::CameraAvStreamManagement::Commands::CaptureSnapshot::Id))
+ {
+ return true;
+ }
+ if ((aCluster == Clusters::CameraAvStreamManagement::Id) &&
+ (aCommand == Clusters::CameraAvStreamManagement::Commands::CaptureSnapshotResponse::Id))
+ {
+ return true;
+ }
+ return false;
+}
+
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
new file mode 100644
index 00000000000000..b20c343ec64379
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
@@ -0,0 +1,48281 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app-common/zap-generated/ids/Commands.h>
+#include <app-common/zap-generated/ids/Events.h>
+#include <app/ConcreteAttributePath.h>
+#include <app/EventLoggingTypes.h>
+#include <app/data-model/DecodableList.h>
+#include <app/data-model/Decode.h>
+#include <app/data-model/Encode.h>
+#include <app/data-model/List.h>
+#include <app/data-model/NullObject.h>
+#include <app/util/basic-types.h>
+#include <lib/core/ClusterEnums.h>
+#include <lib/support/BitMask.h>
+#include <protocols/interaction_model/Constants.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace detail {
+// Structs shared across multiple clusters.
+namespace Structs {
+
+namespace ModeTagStruct {
+enum class Fields : uint8_t
+{
+ kMfgCode = 0,
+ kValue = 1,
+};
+
+struct Type
+{
+public:
+ Optional<chip::VendorId> mfgCode;
+ uint16_t value = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ModeTagStruct
+namespace ModeOptionStruct {
+enum class Fields : uint8_t
+{
+ kLabel = 0,
+ kMode = 1,
+ kModeTags = 2,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan label;
+ uint8_t mode = static_cast<uint8_t>(0);
+ DataModel::List<const Structs::ModeTagStruct::Type> modeTags;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::CharSpan label;
+ uint8_t mode = static_cast<uint8_t>(0);
+ DataModel::DecodableList<Structs::ModeTagStruct::DecodableType> modeTags;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ModeOptionStruct
+namespace MeasurementAccuracyRangeStruct {
+enum class Fields : uint8_t
+{
+ kRangeMin = 0,
+ kRangeMax = 1,
+ kPercentMax = 2,
+ kPercentMin = 3,
+ kPercentTypical = 4,
+ kFixedMax = 5,
+ kFixedMin = 6,
+ kFixedTypical = 7,
+};
+
+struct Type
+{
+public:
+ int64_t rangeMin = static_cast<int64_t>(0);
+ int64_t rangeMax = static_cast<int64_t>(0);
+ Optional<chip::Percent100ths> percentMax;
+ Optional<chip::Percent100ths> percentMin;
+ Optional<chip::Percent100ths> percentTypical;
+ Optional<uint64_t> fixedMax;
+ Optional<uint64_t> fixedMin;
+ Optional<uint64_t> fixedTypical;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MeasurementAccuracyRangeStruct
+namespace MeasurementAccuracyStruct {
+enum class Fields : uint8_t
+{
+ kMeasurementType = 0,
+ kMeasured = 1,
+ kMinMeasuredValue = 2,
+ kMaxMeasuredValue = 3,
+ kAccuracyRanges = 4,
+};
+
+struct Type
+{
+public:
+ MeasurementTypeEnum measurementType = static_cast<MeasurementTypeEnum>(0);
+ bool measured = static_cast<bool>(0);
+ int64_t minMeasuredValue = static_cast<int64_t>(0);
+ int64_t maxMeasuredValue = static_cast<int64_t>(0);
+ DataModel::List<const Structs::MeasurementAccuracyRangeStruct::Type> accuracyRanges;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ MeasurementTypeEnum measurementType = static_cast<MeasurementTypeEnum>(0);
+ bool measured = static_cast<bool>(0);
+ int64_t minMeasuredValue = static_cast<int64_t>(0);
+ int64_t maxMeasuredValue = static_cast<int64_t>(0);
+ DataModel::DecodableList<Structs::MeasurementAccuracyRangeStruct::DecodableType> accuracyRanges;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace MeasurementAccuracyStruct
+namespace DeviceTypeStruct {
+enum class Fields : uint8_t
+{
+ kDeviceType = 0,
+ kRevision = 1,
+};
+
+struct Type
+{
+public:
+ chip::DeviceTypeId deviceType = static_cast<chip::DeviceTypeId>(0);
+ uint16_t revision = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace DeviceTypeStruct
+namespace ApplicationStruct {
+enum class Fields : uint8_t
+{
+ kCatalogVendorID = 0,
+ kApplicationID = 1,
+};
+
+struct Type
+{
+public:
+ uint16_t catalogVendorID = static_cast<uint16_t>(0);
+ chip::CharSpan applicationID;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ApplicationStruct
+namespace ErrorStateStruct {
+enum class Fields : uint8_t
+{
+ kErrorStateID = 0,
+ kErrorStateLabel = 1,
+ kErrorStateDetails = 2,
+};
+
+struct Type
+{
+public:
+ uint8_t errorStateID = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> errorStateLabel;
+ Optional<chip::CharSpan> errorStateDetails;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ErrorStateStruct
+namespace ICEServerStruct {
+enum class Fields : uint8_t
+{
+ kUrls = 1,
+ kUsername = 2,
+ kCredential = 3,
+ kCaid = 4,
+};
+
+struct Type
+{
+public:
+ DataModel::List<const chip::CharSpan> urls;
+ Optional<chip::CharSpan> username;
+ Optional<chip::CharSpan> credential;
+ Optional<uint16_t> caid;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::DecodableList<chip::CharSpan> urls;
+ Optional<chip::CharSpan> username;
+ Optional<chip::CharSpan> credential;
+ Optional<uint16_t> caid;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ICEServerStruct
+namespace LabelStruct {
+enum class Fields : uint8_t
+{
+ kLabel = 0,
+ kValue = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan label;
+ chip::CharSpan value;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace LabelStruct
+namespace OperationalStateStruct {
+enum class Fields : uint8_t
+{
+ kOperationalStateID = 0,
+ kOperationalStateLabel = 1,
+};
+
+struct Type
+{
+public:
+ uint8_t operationalStateID = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> operationalStateLabel;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace OperationalStateStruct
+namespace ViewportStruct {
+enum class Fields : uint8_t
+{
+ kX1 = 0,
+ kY1 = 1,
+ kX2 = 2,
+ kY2 = 3,
+};
+
+struct Type
+{
+public:
+ uint16_t x1 = static_cast<uint16_t>(0);
+ uint16_t y1 = static_cast<uint16_t>(0);
+ uint16_t x2 = static_cast<uint16_t>(0);
+ uint16_t y2 = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ViewportStruct
+namespace WebRTCSessionStruct {
+enum class Fields : uint8_t
+{
+ kId = 1,
+ kPeerNodeID = 2,
+ kPeerFabricIndex = 3,
+ kStreamUsage = 4,
+ kVideoStreamID = 5,
+ kAudioStreamID = 6,
+ kMetadataOptions = 7,
+};
+
+struct Type
+{
+public:
+ uint16_t id = static_cast<uint16_t>(0);
+ chip::NodeId peerNodeID = static_cast<chip::NodeId>(0);
+ chip::FabricIndex peerFabricIndex = static_cast<chip::FabricIndex>(0);
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ DataModel::Nullable<uint16_t> videoStreamID;
+ DataModel::Nullable<uint16_t> audioStreamID;
+ chip::BitMask<WebRTCMetadataOptions> metadataOptions = static_cast<chip::BitMask<WebRTCMetadataOptions>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace WebRTCSessionStruct
+} // namespace Structs
+} // namespace detail
+
+namespace Globals {
+
+// Global structs.
+namespace Structs {
+
+namespace TestGlobalStruct {
+enum class Fields : uint8_t
+{
+ kName = 0,
+ kMyBitmap = 1,
+ kMyEnum = 2,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan name;
+ DataModel::Nullable<chip::BitMask<Globals::TestGlobalBitmap>> myBitmap;
+ Optional<DataModel::Nullable<Globals::TestGlobalEnum>> myEnum;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TestGlobalStruct
+
+namespace LocationDescriptorStruct {
+enum class Fields : uint8_t
+{
+ kLocationName = 0,
+ kFloorNumber = 1,
+ kAreaType = 2,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan locationName;
+ DataModel::Nullable<int16_t> floorNumber;
+ DataModel::Nullable<Globals::AreaTypeTag> areaType;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace LocationDescriptorStruct
+
+namespace AtomicAttributeStatusStruct {
+enum class Fields : uint8_t
+{
+ kAttributeID = 0,
+ kStatusCode = 1,
+};
+
+struct Type
+{
+public:
+ chip::AttributeId attributeID = static_cast<chip::AttributeId>(0);
+ uint8_t statusCode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AtomicAttributeStatusStruct
+
+} // namespace Structs
+
+namespace Attributes {
+namespace GeneratedCommandList {
+struct TypeInfo
+{
+ using Type = DataModel::List<const chip::CommandId>;
+ using DecodableType = DataModel::DecodableList<chip::CommandId>;
+ using DecodableArgType = const DataModel::DecodableList<chip::CommandId> &;
+
+ static constexpr AttributeId GetAttributeId() { return Attributes::GeneratedCommandList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+struct TypeInfo
+{
+ using Type = DataModel::List<const chip::CommandId>;
+ using DecodableType = DataModel::DecodableList<chip::CommandId>;
+ using DecodableArgType = const DataModel::DecodableList<chip::CommandId> &;
+
+ static constexpr AttributeId GetAttributeId() { return Attributes::AcceptedCommandList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+struct TypeInfo
+{
+ using Type = DataModel::List<const chip::AttributeId>;
+ using DecodableType = DataModel::DecodableList<chip::AttributeId>;
+ using DecodableArgType = const DataModel::DecodableList<chip::AttributeId> &;
+
+ static constexpr AttributeId GetAttributeId() { return Attributes::AttributeList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AttributeList
+
+namespace FeatureMap {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr AttributeId GetAttributeId() { return Attributes::FeatureMap::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr AttributeId GetAttributeId() { return Attributes::ClusterRevision::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Globals
+
+namespace Identify {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Identify {
+struct Type;
+struct DecodableType;
+} // namespace Identify
+
+namespace TriggerEffect {
+struct Type;
+struct DecodableType;
+} // namespace TriggerEffect
+
+} // namespace Commands
+
+namespace Commands {
+namespace Identify {
+enum class Fields : uint8_t
+{
+ kIdentifyTime = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Identify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+
+ uint16_t identifyTime = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Identify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+
+ uint16_t identifyTime = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Identify
+namespace TriggerEffect {
+enum class Fields : uint8_t
+{
+ kEffectIdentifier = 0,
+ kEffectVariant = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TriggerEffect::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+
+ EffectIdentifierEnum effectIdentifier = static_cast<EffectIdentifierEnum>(0);
+ EffectVariantEnum effectVariant = static_cast<EffectVariantEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TriggerEffect::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+
+ EffectIdentifierEnum effectIdentifier = static_cast<EffectIdentifierEnum>(0);
+ EffectVariantEnum effectVariant = static_cast<EffectVariantEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TriggerEffect
+} // namespace Commands
+
+namespace Attributes {
+
+namespace IdentifyTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::IdentifyTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace IdentifyTime
+namespace IdentifyType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Identify::IdentifyTypeEnum;
+ using DecodableType = chip::app::Clusters::Identify::IdentifyTypeEnum;
+ using DecodableArgType = chip::app::Clusters::Identify::IdentifyTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::IdentifyType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace IdentifyType
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::IdentifyTime::TypeInfo::DecodableType identifyTime = static_cast<uint16_t>(0);
+ Attributes::IdentifyType::TypeInfo::DecodableType identifyType =
+ static_cast<chip::app::Clusters::Identify::IdentifyTypeEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Identify
+namespace Groups {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace AddGroup {
+struct Type;
+struct DecodableType;
+} // namespace AddGroup
+
+namespace AddGroupResponse {
+struct Type;
+struct DecodableType;
+} // namespace AddGroupResponse
+
+namespace ViewGroup {
+struct Type;
+struct DecodableType;
+} // namespace ViewGroup
+
+namespace ViewGroupResponse {
+struct Type;
+struct DecodableType;
+} // namespace ViewGroupResponse
+
+namespace GetGroupMembership {
+struct Type;
+struct DecodableType;
+} // namespace GetGroupMembership
+
+namespace GetGroupMembershipResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetGroupMembershipResponse
+
+namespace RemoveGroup {
+struct Type;
+struct DecodableType;
+} // namespace RemoveGroup
+
+namespace RemoveGroupResponse {
+struct Type;
+struct DecodableType;
+} // namespace RemoveGroupResponse
+
+namespace RemoveAllGroups {
+struct Type;
+struct DecodableType;
+} // namespace RemoveAllGroups
+
+namespace AddGroupIfIdentifying {
+struct Type;
+struct DecodableType;
+} // namespace AddGroupIfIdentifying
+
+} // namespace Commands
+
+namespace Commands {
+namespace AddGroup {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kGroupName = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddGroup::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ chip::CharSpan groupName;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Groups::Commands::AddGroupResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddGroup::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ chip::CharSpan groupName;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddGroup
+namespace AddGroupResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddGroupResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddGroupResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddGroupResponse
+namespace ViewGroup {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ViewGroup::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Groups::Commands::ViewGroupResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ViewGroup::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewGroup
+namespace ViewGroupResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+ kGroupName = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ViewGroupResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ chip::CharSpan groupName;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ViewGroupResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ chip::CharSpan groupName;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewGroupResponse
+namespace GetGroupMembership {
+enum class Fields : uint8_t
+{
+ kGroupList = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetGroupMembership::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ DataModel::List<const chip::GroupId> groupList;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Groups::Commands::GetGroupMembershipResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetGroupMembership::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ DataModel::DecodableList<chip::GroupId> groupList;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetGroupMembership
+namespace GetGroupMembershipResponse {
+enum class Fields : uint8_t
+{
+ kCapacity = 0,
+ kGroupList = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetGroupMembershipResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ DataModel::Nullable<uint8_t> capacity;
+ DataModel::List<const chip::GroupId> groupList;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetGroupMembershipResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ DataModel::Nullable<uint8_t> capacity;
+ DataModel::DecodableList<chip::GroupId> groupList;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetGroupMembershipResponse
+namespace RemoveGroup {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveGroup::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Groups::Commands::RemoveGroupResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveGroup::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveGroup
+namespace RemoveGroupResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveGroupResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveGroupResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveGroupResponse
+namespace RemoveAllGroups {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveAllGroups::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveAllGroups::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveAllGroups
+namespace AddGroupIfIdentifying {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kGroupName = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddGroupIfIdentifying::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ chip::CharSpan groupName;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddGroupIfIdentifying::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ chip::CharSpan groupName;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddGroupIfIdentifying
+} // namespace Commands
+
+namespace Attributes {
+
+namespace NameSupport {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NameSupport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NameSupport
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::NameSupport::TypeInfo::DecodableType nameSupport =
+ static_cast<chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Groups
+namespace OnOff {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Off {
+struct Type;
+struct DecodableType;
+} // namespace Off
+
+namespace On {
+struct Type;
+struct DecodableType;
+} // namespace On
+
+namespace Toggle {
+struct Type;
+struct DecodableType;
+} // namespace Toggle
+
+namespace OffWithEffect {
+struct Type;
+struct DecodableType;
+} // namespace OffWithEffect
+
+namespace OnWithRecallGlobalScene {
+struct Type;
+struct DecodableType;
+} // namespace OnWithRecallGlobalScene
+
+namespace OnWithTimedOff {
+struct Type;
+struct DecodableType;
+} // namespace OnWithTimedOff
+
+} // namespace Commands
+
+namespace Commands {
+namespace Off {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Off::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Off::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Off
+namespace On {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::On::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::On::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace On
+namespace Toggle {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Toggle::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Toggle::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Toggle
+namespace OffWithEffect {
+enum class Fields : uint8_t
+{
+ kEffectIdentifier = 0,
+ kEffectVariant = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OffWithEffect::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ EffectIdentifierEnum effectIdentifier = static_cast<EffectIdentifierEnum>(0);
+ uint8_t effectVariant = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OffWithEffect::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ EffectIdentifierEnum effectIdentifier = static_cast<EffectIdentifierEnum>(0);
+ uint8_t effectVariant = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OffWithEffect
+namespace OnWithRecallGlobalScene {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OnWithRecallGlobalScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OnWithRecallGlobalScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OnWithRecallGlobalScene
+namespace OnWithTimedOff {
+enum class Fields : uint8_t
+{
+ kOnOffControl = 0,
+ kOnTime = 1,
+ kOffWaitTime = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OnWithTimedOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ chip::BitMask<OnOffControlBitmap> onOffControl = static_cast<chip::BitMask<OnOffControlBitmap>>(0);
+ uint16_t onTime = static_cast<uint16_t>(0);
+ uint16_t offWaitTime = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OnWithTimedOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ chip::BitMask<OnOffControlBitmap> onOffControl = static_cast<chip::BitMask<OnOffControlBitmap>>(0);
+ uint16_t onTime = static_cast<uint16_t>(0);
+ uint16_t offWaitTime = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OnWithTimedOff
+} // namespace Commands
+
+namespace Attributes {
+
+namespace OnOff {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnOff::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnOff
+namespace GlobalSceneControl {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::GlobalSceneControl::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GlobalSceneControl
+namespace OnTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnTime
+namespace OffWaitTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OffWaitTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OffWaitTime
+namespace StartUpOnOff {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpOnOff::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpOnOff
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::OnOff::TypeInfo::DecodableType onOff = static_cast<bool>(0);
+ Attributes::GlobalSceneControl::TypeInfo::DecodableType globalSceneControl = static_cast<bool>(0);
+ Attributes::OnTime::TypeInfo::DecodableType onTime = static_cast<uint16_t>(0);
+ Attributes::OffWaitTime::TypeInfo::DecodableType offWaitTime = static_cast<uint16_t>(0);
+ Attributes::StartUpOnOff::TypeInfo::DecodableType startUpOnOff;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace OnOff
+namespace LevelControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace MoveToLevel {
+struct Type;
+struct DecodableType;
+} // namespace MoveToLevel
+
+namespace Move {
+struct Type;
+struct DecodableType;
+} // namespace Move
+
+namespace Step {
+struct Type;
+struct DecodableType;
+} // namespace Step
+
+namespace Stop {
+struct Type;
+struct DecodableType;
+} // namespace Stop
+
+namespace MoveToLevelWithOnOff {
+struct Type;
+struct DecodableType;
+} // namespace MoveToLevelWithOnOff
+
+namespace MoveWithOnOff {
+struct Type;
+struct DecodableType;
+} // namespace MoveWithOnOff
+
+namespace StepWithOnOff {
+struct Type;
+struct DecodableType;
+} // namespace StepWithOnOff
+
+namespace StopWithOnOff {
+struct Type;
+struct DecodableType;
+} // namespace StopWithOnOff
+
+namespace MoveToClosestFrequency {
+struct Type;
+struct DecodableType;
+} // namespace MoveToClosestFrequency
+
+} // namespace Commands
+
+namespace Commands {
+namespace MoveToLevel {
+enum class Fields : uint8_t
+{
+ kLevel = 0,
+ kTransitionTime = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToLevel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ uint8_t level = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToLevel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ uint8_t level = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToLevel
+namespace Move {
+enum class Fields : uint8_t
+{
+ kMoveMode = 0,
+ kRate = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Move::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ DataModel::Nullable<uint8_t> rate;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Move::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ DataModel::Nullable<uint8_t> rate;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Move
+namespace Step {
+enum class Fields : uint8_t
+{
+ kStepMode = 0,
+ kStepSize = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Step::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Step::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Step
+namespace Stop {
+enum class Fields : uint8_t
+{
+ kOptionsMask = 0,
+ kOptionsOverride = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Stop
+namespace MoveToLevelWithOnOff {
+enum class Fields : uint8_t
+{
+ kLevel = 0,
+ kTransitionTime = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToLevelWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ uint8_t level = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToLevelWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ uint8_t level = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToLevelWithOnOff
+namespace MoveWithOnOff {
+enum class Fields : uint8_t
+{
+ kMoveMode = 0,
+ kRate = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ DataModel::Nullable<uint8_t> rate;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ DataModel::Nullable<uint8_t> rate;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveWithOnOff
+namespace StepWithOnOff {
+enum class Fields : uint8_t
+{
+ kStepMode = 0,
+ kStepSize = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StepWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StepWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint16_t> transitionTime;
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepWithOnOff
+namespace StopWithOnOff {
+enum class Fields : uint8_t
+{
+ kOptionsMask = 0,
+ kOptionsOverride = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StopWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StopWithOnOff::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopWithOnOff
+namespace MoveToClosestFrequency {
+enum class Fields : uint8_t
+{
+ kFrequency = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToClosestFrequency::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ uint16_t frequency = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToClosestFrequency::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ uint16_t frequency = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToClosestFrequency
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CurrentLevel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentLevel
+namespace RemainingTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RemainingTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RemainingTime
+namespace MinLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinLevel
+namespace MaxLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxLevel
+namespace CurrentFrequency {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentFrequency::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentFrequency
+namespace MinFrequency {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinFrequency::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinFrequency
+namespace MaxFrequency {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxFrequency::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxFrequency
+namespace Options {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Options::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Options
+namespace OnOffTransitionTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnOffTransitionTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnOffTransitionTime
+namespace OnLevel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnLevel
+namespace OnTransitionTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnTransitionTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnTransitionTime
+namespace OffTransitionTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OffTransitionTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OffTransitionTime
+namespace DefaultMoveRate {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultMoveRate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultMoveRate
+namespace StartUpCurrentLevel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpCurrentLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpCurrentLevel
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CurrentLevel::TypeInfo::DecodableType currentLevel;
+ Attributes::RemainingTime::TypeInfo::DecodableType remainingTime = static_cast<uint16_t>(0);
+ Attributes::MinLevel::TypeInfo::DecodableType minLevel = static_cast<uint8_t>(0);
+ Attributes::MaxLevel::TypeInfo::DecodableType maxLevel = static_cast<uint8_t>(0);
+ Attributes::CurrentFrequency::TypeInfo::DecodableType currentFrequency = static_cast<uint16_t>(0);
+ Attributes::MinFrequency::TypeInfo::DecodableType minFrequency = static_cast<uint16_t>(0);
+ Attributes::MaxFrequency::TypeInfo::DecodableType maxFrequency = static_cast<uint16_t>(0);
+ Attributes::Options::TypeInfo::DecodableType options =
+ static_cast<chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>>(0);
+ Attributes::OnOffTransitionTime::TypeInfo::DecodableType onOffTransitionTime = static_cast<uint16_t>(0);
+ Attributes::OnLevel::TypeInfo::DecodableType onLevel;
+ Attributes::OnTransitionTime::TypeInfo::DecodableType onTransitionTime;
+ Attributes::OffTransitionTime::TypeInfo::DecodableType offTransitionTime;
+ Attributes::DefaultMoveRate::TypeInfo::DecodableType defaultMoveRate;
+ Attributes::StartUpCurrentLevel::TypeInfo::DecodableType startUpCurrentLevel;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace LevelControl
+namespace PulseWidthModulation {
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace PulseWidthModulation
+namespace Descriptor {
+namespace Structs {
+namespace DeviceTypeStruct = Clusters::detail::Structs::DeviceTypeStruct;
+namespace SemanticTagStruct {
+enum class Fields : uint8_t
+{
+ kMfgCode = 0,
+ kNamespaceID = 1,
+ kTag = 2,
+ kLabel = 3,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<chip::VendorId> mfgCode;
+ uint8_t namespaceID = static_cast<uint8_t>(0);
+ uint8_t tag = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<chip::CharSpan>> label;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SemanticTagStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace DeviceTypeList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DeviceTypeList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DeviceTypeList
+namespace ServerList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ClusterId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ClusterId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ClusterId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ServerList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ServerList
+namespace ClientList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ClusterId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ClusterId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ClusterId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ClientList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ClientList
+namespace PartsList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::EndpointId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::EndpointId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PartsList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PartsList
+namespace TagList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Descriptor::Structs::SemanticTagStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::SemanticTagStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::SemanticTagStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TagList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TagList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::DeviceTypeList::TypeInfo::DecodableType deviceTypeList;
+ Attributes::ServerList::TypeInfo::DecodableType serverList;
+ Attributes::ClientList::TypeInfo::DecodableType clientList;
+ Attributes::PartsList::TypeInfo::DecodableType partsList;
+ Attributes::TagList::TypeInfo::DecodableType tagList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Descriptor
+namespace Binding {
+namespace Structs {
+namespace TargetStruct {
+enum class Fields : uint8_t
+{
+ kNode = 1,
+ kGroup = 2,
+ kEndpoint = 3,
+ kCluster = 4,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ Optional<chip::NodeId> node;
+ Optional<chip::GroupId> group;
+ Optional<chip::EndpointId> endpoint;
+ Optional<chip::ClusterId> cluster;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TargetStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace Binding {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Binding::Structs::TargetStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Binding::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Binding
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Binding::TypeInfo::DecodableType binding;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Binding
+namespace AccessControl {
+namespace Structs {
+namespace AccessRestrictionStruct {
+enum class Fields : uint8_t
+{
+ kType = 0,
+ kId = 1,
+};
+
+struct Type
+{
+public:
+ AccessRestrictionTypeEnum type = static_cast<AccessRestrictionTypeEnum>(0);
+ DataModel::Nullable<uint32_t> id;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AccessRestrictionStruct
+namespace CommissioningAccessRestrictionEntryStruct {
+enum class Fields : uint8_t
+{
+ kEndpoint = 0,
+ kCluster = 1,
+ kRestrictions = 2,
+};
+
+struct Type
+{
+public:
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+ chip::ClusterId cluster = static_cast<chip::ClusterId>(0);
+ DataModel::List<const Structs::AccessRestrictionStruct::Type> restrictions;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+ chip::ClusterId cluster = static_cast<chip::ClusterId>(0);
+ DataModel::DecodableList<Structs::AccessRestrictionStruct::DecodableType> restrictions;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace CommissioningAccessRestrictionEntryStruct
+namespace AccessRestrictionEntryStruct {
+enum class Fields : uint8_t
+{
+ kEndpoint = 0,
+ kCluster = 1,
+ kRestrictions = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+ chip::ClusterId cluster = static_cast<chip::ClusterId>(0);
+ DataModel::List<const Structs::AccessRestrictionStruct::Type> restrictions;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+ chip::ClusterId cluster = static_cast<chip::ClusterId>(0);
+ DataModel::DecodableList<Structs::AccessRestrictionStruct::DecodableType> restrictions;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+};
+
+} // namespace AccessRestrictionEntryStruct
+namespace AccessControlTargetStruct {
+enum class Fields : uint8_t
+{
+ kCluster = 0,
+ kEndpoint = 1,
+ kDeviceType = 2,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<chip::ClusterId> cluster;
+ DataModel::Nullable<chip::EndpointId> endpoint;
+ DataModel::Nullable<chip::DeviceTypeId> deviceType;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AccessControlTargetStruct
+namespace AccessControlEntryStruct {
+enum class Fields : uint8_t
+{
+ kPrivilege = 1,
+ kAuthMode = 2,
+ kSubjects = 3,
+ kTargets = 4,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ AccessControlEntryPrivilegeEnum privilege = static_cast<AccessControlEntryPrivilegeEnum>(0);
+ AccessControlEntryAuthModeEnum authMode = static_cast<AccessControlEntryAuthModeEnum>(0);
+ DataModel::Nullable<DataModel::List<const uint64_t>> subjects;
+ DataModel::Nullable<DataModel::List<const Structs::AccessControlTargetStruct::Type>> targets;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+struct DecodableType
+{
+public:
+ AccessControlEntryPrivilegeEnum privilege = static_cast<AccessControlEntryPrivilegeEnum>(0);
+ AccessControlEntryAuthModeEnum authMode = static_cast<AccessControlEntryAuthModeEnum>(0);
+ DataModel::Nullable<DataModel::DecodableList<uint64_t>> subjects;
+ DataModel::Nullable<DataModel::DecodableList<Structs::AccessControlTargetStruct::DecodableType>> targets;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+};
+
+} // namespace AccessControlEntryStruct
+namespace AccessControlExtensionStruct {
+enum class Fields : uint8_t
+{
+ kData = 1,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan data;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AccessControlExtensionStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ReviewFabricRestrictions {
+struct Type;
+struct DecodableType;
+} // namespace ReviewFabricRestrictions
+
+namespace ReviewFabricRestrictionsResponse {
+struct Type;
+struct DecodableType;
+} // namespace ReviewFabricRestrictionsResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ReviewFabricRestrictions {
+enum class Fields : uint8_t
+{
+ kArl = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ReviewFabricRestrictions::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ DataModel::List<const Structs::CommissioningAccessRestrictionEntryStruct::Type> arl;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::AccessControl::Commands::ReviewFabricRestrictionsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ReviewFabricRestrictions::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ DataModel::DecodableList<Structs::CommissioningAccessRestrictionEntryStruct::DecodableType> arl;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ReviewFabricRestrictions
+namespace ReviewFabricRestrictionsResponse {
+enum class Fields : uint8_t
+{
+ kToken = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ReviewFabricRestrictionsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ uint64_t token = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ReviewFabricRestrictionsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ uint64_t token = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ReviewFabricRestrictionsResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Acl {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Acl::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Acl
+namespace Extension {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Extension::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Extension
+namespace SubjectsPerAccessControlEntry {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SubjectsPerAccessControlEntry::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SubjectsPerAccessControlEntry
+namespace TargetsPerAccessControlEntry {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TargetsPerAccessControlEntry::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TargetsPerAccessControlEntry
+namespace AccessControlEntriesPerFabric {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AccessControlEntriesPerFabric::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AccessControlEntriesPerFabric
+namespace CommissioningARL {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<
+ const chip::app::Clusters::AccessControl::Structs::CommissioningAccessRestrictionEntryStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::CommissioningAccessRestrictionEntryStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::CommissioningAccessRestrictionEntryStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CommissioningARL::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CommissioningARL
+namespace Arl {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessRestrictionEntryStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::AccessRestrictionEntryStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::AccessControl::Structs::AccessRestrictionEntryStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Arl::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Arl
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Acl::TypeInfo::DecodableType acl;
+ Attributes::Extension::TypeInfo::DecodableType extension;
+ Attributes::SubjectsPerAccessControlEntry::TypeInfo::DecodableType subjectsPerAccessControlEntry = static_cast<uint16_t>(0);
+ Attributes::TargetsPerAccessControlEntry::TypeInfo::DecodableType targetsPerAccessControlEntry = static_cast<uint16_t>(0);
+ Attributes::AccessControlEntriesPerFabric::TypeInfo::DecodableType accessControlEntriesPerFabric = static_cast<uint16_t>(0);
+ Attributes::CommissioningARL::TypeInfo::DecodableType commissioningARL;
+ Attributes::Arl::TypeInfo::DecodableType arl;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace AccessControlEntryChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kAdminNodeID = 1,
+ kAdminPasscodeID = 2,
+ kChangeType = 3,
+ kLatestValue = 4,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AccessControlEntryChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr bool kIsFabricScoped = true;
+
+ DataModel::Nullable<chip::NodeId> adminNodeID;
+ DataModel::Nullable<uint16_t> adminPasscodeID;
+ ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0);
+ DataModel::Nullable<Structs::AccessControlEntryStruct::Type> latestValue;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AccessControlEntryChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ DataModel::Nullable<chip::NodeId> adminNodeID;
+ DataModel::Nullable<uint16_t> adminPasscodeID;
+ ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0);
+ DataModel::Nullable<Structs::AccessControlEntryStruct::DecodableType> latestValue;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AccessControlEntryChanged
+namespace AccessControlExtensionChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kAdminNodeID = 1,
+ kAdminPasscodeID = 2,
+ kChangeType = 3,
+ kLatestValue = 4,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AccessControlExtensionChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr bool kIsFabricScoped = true;
+
+ DataModel::Nullable<chip::NodeId> adminNodeID;
+ DataModel::Nullable<uint16_t> adminPasscodeID;
+ ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0);
+ DataModel::Nullable<Structs::AccessControlExtensionStruct::Type> latestValue;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AccessControlExtensionChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ DataModel::Nullable<chip::NodeId> adminNodeID;
+ DataModel::Nullable<uint16_t> adminPasscodeID;
+ ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0);
+ DataModel::Nullable<Structs::AccessControlExtensionStruct::DecodableType> latestValue;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AccessControlExtensionChanged
+namespace FabricRestrictionReviewUpdate {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kToken = 0,
+ kInstruction = 1,
+ kARLRequestFlowUrl = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::FabricRestrictionReviewUpdate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+ static constexpr bool kIsFabricScoped = true;
+
+ uint64_t token = static_cast<uint64_t>(0);
+ Optional<chip::CharSpan> instruction;
+ Optional<chip::CharSpan> ARLRequestFlowUrl;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::FabricRestrictionReviewUpdate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; }
+
+ uint64_t token = static_cast<uint64_t>(0);
+ Optional<chip::CharSpan> instruction;
+ Optional<chip::CharSpan> ARLRequestFlowUrl;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace FabricRestrictionReviewUpdate
+} // namespace Events
+} // namespace AccessControl
+namespace Actions {
+namespace Structs {
+namespace ActionStruct {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kName = 1,
+ kType = 2,
+ kEndpointListID = 3,
+ kSupportedCommands = 4,
+ kState = 5,
+};
+
+struct Type
+{
+public:
+ uint16_t actionID = static_cast<uint16_t>(0);
+ chip::CharSpan name;
+ ActionTypeEnum type = static_cast<ActionTypeEnum>(0);
+ uint16_t endpointListID = static_cast<uint16_t>(0);
+ chip::BitMask<CommandBits> supportedCommands = static_cast<chip::BitMask<CommandBits>>(0);
+ ActionStateEnum state = static_cast<ActionStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ActionStruct
+namespace EndpointListStruct {
+enum class Fields : uint8_t
+{
+ kEndpointListID = 0,
+ kName = 1,
+ kType = 2,
+ kEndpoints = 3,
+};
+
+struct Type
+{
+public:
+ uint16_t endpointListID = static_cast<uint16_t>(0);
+ chip::CharSpan name;
+ EndpointListTypeEnum type = static_cast<EndpointListTypeEnum>(0);
+ DataModel::List<const chip::EndpointId> endpoints;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ uint16_t endpointListID = static_cast<uint16_t>(0);
+ chip::CharSpan name;
+ EndpointListTypeEnum type = static_cast<EndpointListTypeEnum>(0);
+ DataModel::DecodableList<chip::EndpointId> endpoints;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace EndpointListStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace InstantAction {
+struct Type;
+struct DecodableType;
+} // namespace InstantAction
+
+namespace InstantActionWithTransition {
+struct Type;
+struct DecodableType;
+} // namespace InstantActionWithTransition
+
+namespace StartAction {
+struct Type;
+struct DecodableType;
+} // namespace StartAction
+
+namespace StartActionWithDuration {
+struct Type;
+struct DecodableType;
+} // namespace StartActionWithDuration
+
+namespace StopAction {
+struct Type;
+struct DecodableType;
+} // namespace StopAction
+
+namespace PauseAction {
+struct Type;
+struct DecodableType;
+} // namespace PauseAction
+
+namespace PauseActionWithDuration {
+struct Type;
+struct DecodableType;
+} // namespace PauseActionWithDuration
+
+namespace ResumeAction {
+struct Type;
+struct DecodableType;
+} // namespace ResumeAction
+
+namespace EnableAction {
+struct Type;
+struct DecodableType;
+} // namespace EnableAction
+
+namespace EnableActionWithDuration {
+struct Type;
+struct DecodableType;
+} // namespace EnableActionWithDuration
+
+namespace DisableAction {
+struct Type;
+struct DecodableType;
+} // namespace DisableAction
+
+namespace DisableActionWithDuration {
+struct Type;
+struct DecodableType;
+} // namespace DisableActionWithDuration
+
+} // namespace Commands
+
+namespace Commands {
+namespace InstantAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::InstantAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::InstantAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace InstantAction
+namespace InstantActionWithTransition {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kTransitionTime = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::InstantActionWithTransition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::InstantActionWithTransition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace InstantActionWithTransition
+namespace StartAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StartAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StartAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartAction
+namespace StartActionWithDuration {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kDuration = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StartActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StartActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartActionWithDuration
+namespace StopAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StopAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StopAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopAction
+namespace PauseAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PauseAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PauseAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PauseAction
+namespace PauseActionWithDuration {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kDuration = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PauseActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PauseActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PauseActionWithDuration
+namespace ResumeAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResumeAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResumeAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResumeAction
+namespace EnableAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnableAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnableAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableAction
+namespace EnableActionWithDuration {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kDuration = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnableActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnableActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableActionWithDuration
+namespace DisableAction {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DisableAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DisableAction::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DisableAction
+namespace DisableActionWithDuration {
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kDuration = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DisableActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DisableActionWithDuration::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ Optional<uint32_t> invokeID;
+ uint32_t duration = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DisableActionWithDuration
+} // namespace Commands
+
+namespace Attributes {
+
+namespace ActionList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Actions::Structs::ActionStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActionList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActionList
+namespace EndpointLists {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Actions::Structs::EndpointListStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EndpointLists::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EndpointLists
+namespace SetupURL {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SetupURL::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 512; }
+};
+} // namespace SetupURL
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::ActionList::TypeInfo::DecodableType actionList;
+ Attributes::EndpointLists::TypeInfo::DecodableType endpointLists;
+ Attributes::SetupURL::TypeInfo::DecodableType setupURL;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace StateChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kNewState = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ uint32_t invokeID = static_cast<uint32_t>(0);
+ ActionStateEnum newState = static_cast<ActionStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ uint32_t invokeID = static_cast<uint32_t>(0);
+ ActionStateEnum newState = static_cast<ActionStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace StateChanged
+namespace ActionFailed {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kActionID = 0,
+ kInvokeID = 1,
+ kNewState = 2,
+ kError = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ActionFailed::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ uint32_t invokeID = static_cast<uint32_t>(0);
+ ActionStateEnum newState = static_cast<ActionStateEnum>(0);
+ ActionErrorEnum error = static_cast<ActionErrorEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ActionFailed::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
+
+ uint16_t actionID = static_cast<uint16_t>(0);
+ uint32_t invokeID = static_cast<uint32_t>(0);
+ ActionStateEnum newState = static_cast<ActionStateEnum>(0);
+ ActionErrorEnum error = static_cast<ActionErrorEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ActionFailed
+} // namespace Events
+} // namespace Actions
+namespace BasicInformation {
+namespace Structs {
+namespace CapabilityMinimaStruct {
+enum class Fields : uint8_t
+{
+ kCaseSessionsPerFabric = 0,
+ kSubscriptionsPerFabric = 1,
+};
+
+struct Type
+{
+public:
+ uint16_t caseSessionsPerFabric = static_cast<uint16_t>(0);
+ uint16_t subscriptionsPerFabric = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace CapabilityMinimaStruct
+namespace ProductAppearanceStruct {
+enum class Fields : uint8_t
+{
+ kFinish = 0,
+ kPrimaryColor = 1,
+};
+
+struct Type
+{
+public:
+ ProductFinishEnum finish = static_cast<ProductFinishEnum>(0);
+ DataModel::Nullable<ColorEnum> primaryColor;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ProductAppearanceStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace MfgSpecificPing {
+struct Type;
+struct DecodableType;
+} // namespace MfgSpecificPing
+
+} // namespace Commands
+
+namespace Commands {
+namespace MfgSpecificPing {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MfgSpecificPing::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MfgSpecificPing::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MfgSpecificPing
+} // namespace Commands
+
+namespace Attributes {
+
+namespace DataModelRevision {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DataModelRevision::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DataModelRevision
+namespace VendorName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace VendorName
+namespace VendorID {
+struct TypeInfo
+{
+ using Type = chip::VendorId;
+ using DecodableType = chip::VendorId;
+ using DecodableArgType = chip::VendorId;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace VendorID
+namespace ProductName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace ProductName
+namespace ProductID {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ProductID
+namespace NodeLabel {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NodeLabel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace NodeLabel
+namespace Location {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Location::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 2; }
+};
+} // namespace Location
+namespace HardwareVersion {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HardwareVersion
+namespace HardwareVersionString {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersionString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace HardwareVersionString
+namespace SoftwareVersion {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SoftwareVersion
+namespace SoftwareVersionString {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersionString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace SoftwareVersionString
+namespace ManufacturingDate {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ManufacturingDate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace ManufacturingDate
+namespace PartNumber {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace PartNumber
+namespace ProductURL {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductURL::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 256; }
+};
+} // namespace ProductURL
+namespace ProductLabel {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductLabel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace ProductLabel
+namespace SerialNumber {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SerialNumber::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace SerialNumber
+namespace LocalConfigDisabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalConfigDisabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalConfigDisabled
+namespace Reachable {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Reachable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Reachable
+namespace UniqueID {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UniqueID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace UniqueID
+namespace CapabilityMinima {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::BasicInformation::Structs::CapabilityMinimaStruct::Type;
+ using DecodableType = chip::app::Clusters::BasicInformation::Structs::CapabilityMinimaStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::BasicInformation::Structs::CapabilityMinimaStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CapabilityMinima::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CapabilityMinima
+namespace ProductAppearance {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::BasicInformation::Structs::ProductAppearanceStruct::Type;
+ using DecodableType = chip::app::Clusters::BasicInformation::Structs::ProductAppearanceStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::BasicInformation::Structs::ProductAppearanceStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductAppearance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ProductAppearance
+namespace SpecificationVersion {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpecificationVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpecificationVersion
+namespace MaxPathsPerInvoke {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxPathsPerInvoke::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxPathsPerInvoke
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::DataModelRevision::TypeInfo::DecodableType dataModelRevision = static_cast<uint16_t>(0);
+ Attributes::VendorName::TypeInfo::DecodableType vendorName;
+ Attributes::VendorID::TypeInfo::DecodableType vendorID = static_cast<chip::VendorId>(0);
+ Attributes::ProductName::TypeInfo::DecodableType productName;
+ Attributes::ProductID::TypeInfo::DecodableType productID = static_cast<uint16_t>(0);
+ Attributes::NodeLabel::TypeInfo::DecodableType nodeLabel;
+ Attributes::Location::TypeInfo::DecodableType location;
+ Attributes::HardwareVersion::TypeInfo::DecodableType hardwareVersion = static_cast<uint16_t>(0);
+ Attributes::HardwareVersionString::TypeInfo::DecodableType hardwareVersionString;
+ Attributes::SoftwareVersion::TypeInfo::DecodableType softwareVersion = static_cast<uint32_t>(0);
+ Attributes::SoftwareVersionString::TypeInfo::DecodableType softwareVersionString;
+ Attributes::ManufacturingDate::TypeInfo::DecodableType manufacturingDate;
+ Attributes::PartNumber::TypeInfo::DecodableType partNumber;
+ Attributes::ProductURL::TypeInfo::DecodableType productURL;
+ Attributes::ProductLabel::TypeInfo::DecodableType productLabel;
+ Attributes::SerialNumber::TypeInfo::DecodableType serialNumber;
+ Attributes::LocalConfigDisabled::TypeInfo::DecodableType localConfigDisabled = static_cast<bool>(0);
+ Attributes::Reachable::TypeInfo::DecodableType reachable = static_cast<bool>(0);
+ Attributes::UniqueID::TypeInfo::DecodableType uniqueID;
+ Attributes::CapabilityMinima::TypeInfo::DecodableType capabilityMinima;
+ Attributes::ProductAppearance::TypeInfo::DecodableType productAppearance;
+ Attributes::SpecificationVersion::TypeInfo::DecodableType specificationVersion = static_cast<uint32_t>(0);
+ Attributes::MaxPathsPerInvoke::TypeInfo::DecodableType maxPathsPerInvoke = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace StartUp {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kSoftwareVersion = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StartUp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StartUp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace StartUp
+namespace ShutDown {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ShutDown::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ShutDown::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ShutDown
+namespace Leave {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kFabricIndex = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Leave::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Leave::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Leave
+namespace ReachableChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kReachableNewValue = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ bool reachableNewValue = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BasicInformation::Id; }
+
+ bool reachableNewValue = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ReachableChanged
+} // namespace Events
+} // namespace BasicInformation
+namespace OtaSoftwareUpdateProvider {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace QueryImage {
+struct Type;
+struct DecodableType;
+} // namespace QueryImage
+
+namespace QueryImageResponse {
+struct Type;
+struct DecodableType;
+} // namespace QueryImageResponse
+
+namespace ApplyUpdateRequest {
+struct Type;
+struct DecodableType;
+} // namespace ApplyUpdateRequest
+
+namespace ApplyUpdateResponse {
+struct Type;
+struct DecodableType;
+} // namespace ApplyUpdateResponse
+
+namespace NotifyUpdateApplied {
+struct Type;
+struct DecodableType;
+} // namespace NotifyUpdateApplied
+
+} // namespace Commands
+
+namespace Commands {
+namespace QueryImage {
+enum class Fields : uint8_t
+{
+ kVendorID = 0,
+ kProductID = 1,
+ kSoftwareVersion = 2,
+ kProtocolsSupported = 3,
+ kHardwareVersion = 4,
+ kLocation = 5,
+ kRequestorCanConsent = 6,
+ kMetadataForProvider = 7,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::QueryImage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ uint16_t productID = static_cast<uint16_t>(0);
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ DataModel::List<const DownloadProtocolEnum> protocolsSupported;
+ Optional<uint16_t> hardwareVersion;
+ Optional<chip::CharSpan> location;
+ Optional<bool> requestorCanConsent;
+ Optional<chip::ByteSpan> metadataForProvider;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::QueryImage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ uint16_t productID = static_cast<uint16_t>(0);
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ DataModel::DecodableList<DownloadProtocolEnum> protocolsSupported;
+ Optional<uint16_t> hardwareVersion;
+ Optional<chip::CharSpan> location;
+ Optional<bool> requestorCanConsent;
+ Optional<chip::ByteSpan> metadataForProvider;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace QueryImage
+namespace QueryImageResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kDelayedActionTime = 1,
+ kImageURI = 2,
+ kSoftwareVersion = 3,
+ kSoftwareVersionString = 4,
+ kUpdateToken = 5,
+ kUserConsentNeeded = 6,
+ kMetadataForRequestor = 7,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::QueryImageResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<uint32_t> delayedActionTime;
+ Optional<chip::CharSpan> imageURI;
+ Optional<uint32_t> softwareVersion;
+ Optional<chip::CharSpan> softwareVersionString;
+ Optional<chip::ByteSpan> updateToken;
+ Optional<bool> userConsentNeeded;
+ Optional<chip::ByteSpan> metadataForRequestor;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::QueryImageResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<uint32_t> delayedActionTime;
+ Optional<chip::CharSpan> imageURI;
+ Optional<uint32_t> softwareVersion;
+ Optional<chip::CharSpan> softwareVersionString;
+ Optional<chip::ByteSpan> updateToken;
+ Optional<bool> userConsentNeeded;
+ Optional<chip::ByteSpan> metadataForRequestor;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace QueryImageResponse
+namespace ApplyUpdateRequest {
+enum class Fields : uint8_t
+{
+ kUpdateToken = 0,
+ kNewVersion = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ chip::ByteSpan updateToken;
+ uint32_t newVersion = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ chip::ByteSpan updateToken;
+ uint32_t newVersion = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ApplyUpdateRequest
+namespace ApplyUpdateResponse {
+enum class Fields : uint8_t
+{
+ kAction = 0,
+ kDelayedActionTime = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ ApplyUpdateActionEnum action = static_cast<ApplyUpdateActionEnum>(0);
+ uint32_t delayedActionTime = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ ApplyUpdateActionEnum action = static_cast<ApplyUpdateActionEnum>(0);
+ uint32_t delayedActionTime = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ApplyUpdateResponse
+namespace NotifyUpdateApplied {
+enum class Fields : uint8_t
+{
+ kUpdateToken = 0,
+ kSoftwareVersion = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NotifyUpdateApplied::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ chip::ByteSpan updateToken;
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NotifyUpdateApplied::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ chip::ByteSpan updateToken;
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NotifyUpdateApplied
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateProvider
+namespace OtaSoftwareUpdateRequestor {
+namespace Structs {
+namespace ProviderLocation {
+enum class Fields : uint8_t
+{
+ kProviderNodeID = 1,
+ kEndpoint = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::NodeId providerNodeID = static_cast<chip::NodeId>(0);
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ProviderLocation
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace AnnounceOTAProvider {
+struct Type;
+struct DecodableType;
+} // namespace AnnounceOTAProvider
+
+} // namespace Commands
+
+namespace Commands {
+namespace AnnounceOTAProvider {
+enum class Fields : uint8_t
+{
+ kProviderNodeID = 0,
+ kVendorID = 1,
+ kAnnouncementReason = 2,
+ kMetadataForNode = 3,
+ kEndpoint = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AnnounceOTAProvider::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+
+ chip::NodeId providerNodeID = static_cast<chip::NodeId>(0);
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ AnnouncementReasonEnum announcementReason = static_cast<AnnouncementReasonEnum>(0);
+ Optional<chip::ByteSpan> metadataForNode;
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AnnounceOTAProvider::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+
+ chip::NodeId providerNodeID = static_cast<chip::NodeId>(0);
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ AnnouncementReasonEnum announcementReason = static_cast<AnnouncementReasonEnum>(0);
+ Optional<chip::ByteSpan> metadataForNode;
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AnnounceOTAProvider
+} // namespace Commands
+
+namespace Attributes {
+
+namespace DefaultOTAProviders {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultOTAProviders::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultOTAProviders
+namespace UpdatePossible {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UpdatePossible::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UpdatePossible
+namespace UpdateState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum;
+ using DecodableType = chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum;
+ using DecodableArgType = chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UpdateState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UpdateState
+namespace UpdateStateProgress {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UpdateStateProgress::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UpdateStateProgress
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::DefaultOTAProviders::TypeInfo::DecodableType defaultOTAProviders;
+ Attributes::UpdatePossible::TypeInfo::DecodableType updatePossible = static_cast<bool>(0);
+ Attributes::UpdateState::TypeInfo::DecodableType updateState =
+ static_cast<chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum>(0);
+ Attributes::UpdateStateProgress::TypeInfo::DecodableType updateStateProgress;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace StateTransition {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kPreviousState = 0,
+ kNewState = 1,
+ kReason = 2,
+ kTargetSoftwareVersion = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateTransition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ UpdateStateEnum previousState = static_cast<UpdateStateEnum>(0);
+ UpdateStateEnum newState = static_cast<UpdateStateEnum>(0);
+ ChangeReasonEnum reason = static_cast<ChangeReasonEnum>(0);
+ DataModel::Nullable<uint32_t> targetSoftwareVersion;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateTransition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+
+ UpdateStateEnum previousState = static_cast<UpdateStateEnum>(0);
+ UpdateStateEnum newState = static_cast<UpdateStateEnum>(0);
+ ChangeReasonEnum reason = static_cast<ChangeReasonEnum>(0);
+ DataModel::Nullable<uint32_t> targetSoftwareVersion;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace StateTransition
+namespace VersionApplied {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kSoftwareVersion = 0,
+ kProductID = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::VersionApplied::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ uint16_t productID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::VersionApplied::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ uint16_t productID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace VersionApplied
+namespace DownloadError {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSoftwareVersion = 0,
+ kBytesDownloaded = 1,
+ kProgressPercent = 2,
+ kPlatformCode = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DownloadError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ uint64_t bytesDownloaded = static_cast<uint64_t>(0);
+ DataModel::Nullable<uint8_t> progressPercent;
+ DataModel::Nullable<int64_t> platformCode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DownloadError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; }
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+ uint64_t bytesDownloaded = static_cast<uint64_t>(0);
+ DataModel::Nullable<uint8_t> progressPercent;
+ DataModel::Nullable<int64_t> platformCode;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace DownloadError
+} // namespace Events
+} // namespace OtaSoftwareUpdateRequestor
+namespace LocalizationConfiguration {
+
+namespace Attributes {
+
+namespace ActiveLocale {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveLocale::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 35; }
+};
+} // namespace ActiveLocale
+namespace SupportedLocales {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedLocales::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedLocales
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::ActiveLocale::TypeInfo::DecodableType activeLocale;
+ Attributes::SupportedLocales::TypeInfo::DecodableType supportedLocales;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace LocalizationConfiguration
+namespace TimeFormatLocalization {
+
+namespace Attributes {
+
+namespace HourFormat {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TimeFormatLocalization::HourFormatEnum;
+ using DecodableType = chip::app::Clusters::TimeFormatLocalization::HourFormatEnum;
+ using DecodableArgType = chip::app::Clusters::TimeFormatLocalization::HourFormatEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HourFormat::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HourFormat
+namespace ActiveCalendarType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum;
+ using DecodableType = chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum;
+ using DecodableArgType = chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveCalendarType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveCalendarType
+namespace SupportedCalendarTypes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedCalendarTypes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedCalendarTypes
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::HourFormat::TypeInfo::DecodableType hourFormat =
+ static_cast<chip::app::Clusters::TimeFormatLocalization::HourFormatEnum>(0);
+ Attributes::ActiveCalendarType::TypeInfo::DecodableType activeCalendarType =
+ static_cast<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>(0);
+ Attributes::SupportedCalendarTypes::TypeInfo::DecodableType supportedCalendarTypes;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace TimeFormatLocalization
+namespace UnitLocalization {
+
+namespace Attributes {
+
+namespace TemperatureUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::UnitLocalization::TempUnitEnum;
+ using DecodableType = chip::app::Clusters::UnitLocalization::TempUnitEnum;
+ using DecodableArgType = chip::app::Clusters::UnitLocalization::TempUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TemperatureUnit
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::TemperatureUnit::TypeInfo::DecodableType temperatureUnit =
+ static_cast<chip::app::Clusters::UnitLocalization::TempUnitEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace UnitLocalization
+namespace PowerSourceConfiguration {
+
+namespace Attributes {
+
+namespace Sources {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::EndpointId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::EndpointId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Sources::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Sources
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Sources::TypeInfo::DecodableType sources;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace PowerSourceConfiguration
+namespace PowerSource {
+namespace Structs {
+namespace BatChargeFaultChangeType {
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ DataModel::List<const BatChargeFaultEnum> current;
+ DataModel::List<const BatChargeFaultEnum> previous;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::DecodableList<BatChargeFaultEnum> current;
+ DataModel::DecodableList<BatChargeFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace BatChargeFaultChangeType
+namespace BatFaultChangeType {
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ DataModel::List<const BatFaultEnum> current;
+ DataModel::List<const BatFaultEnum> previous;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::DecodableList<BatFaultEnum> current;
+ DataModel::DecodableList<BatFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace BatFaultChangeType
+namespace WiredFaultChangeType {
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ DataModel::List<const WiredFaultEnum> current;
+ DataModel::List<const WiredFaultEnum> previous;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::DecodableList<WiredFaultEnum> current;
+ DataModel::DecodableList<WiredFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace WiredFaultChangeType
+} // namespace Structs
+
+namespace Attributes {
+
+namespace Status {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Status::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Status
+namespace Order {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Order::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Order
+namespace Description {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 60; }
+};
+} // namespace Description
+namespace WiredAssessedInputVoltage {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputVoltage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredAssessedInputVoltage
+namespace WiredAssessedInputFrequency {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputFrequency::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredAssessedInputFrequency
+namespace WiredCurrentType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredCurrentType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredCurrentType
+namespace WiredAssessedCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredAssessedCurrent
+namespace WiredNominalVoltage {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredNominalVoltage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredNominalVoltage
+namespace WiredMaximumCurrent {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredMaximumCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredMaximumCurrent
+namespace WiredPresent {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiredPresent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiredPresent
+namespace ActiveWiredFaults {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::WiredFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFaultEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveWiredFaults::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveWiredFaults
+namespace BatVoltage {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatVoltage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatVoltage
+namespace BatPercentRemaining {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatPercentRemaining::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatPercentRemaining
+namespace BatTimeRemaining {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatTimeRemaining::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatTimeRemaining
+namespace BatChargeLevel {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::BatChargeLevelEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::BatChargeLevelEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::BatChargeLevelEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatChargeLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatChargeLevel
+namespace BatReplacementNeeded {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatReplacementNeeded::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatReplacementNeeded
+namespace BatReplaceability {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatReplaceability::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatReplaceability
+namespace BatPresent {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatPresent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatPresent
+namespace ActiveBatFaults {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFaultEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatFaults::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveBatFaults
+namespace BatReplacementDescription {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatReplacementDescription::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 60; }
+};
+} // namespace BatReplacementDescription
+namespace BatCommonDesignation {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatCommonDesignation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatCommonDesignation
+namespace BatANSIDesignation {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatANSIDesignation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 20; }
+};
+} // namespace BatANSIDesignation
+namespace BatIECDesignation {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatIECDesignation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 20; }
+};
+} // namespace BatIECDesignation
+namespace BatApprovedChemistry {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatApprovedChemistry::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatApprovedChemistry
+namespace BatCapacity {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatCapacity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatCapacity
+namespace BatQuantity {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatQuantity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatQuantity
+namespace BatChargeState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PowerSource::BatChargeStateEnum;
+ using DecodableType = chip::app::Clusters::PowerSource::BatChargeStateEnum;
+ using DecodableArgType = chip::app::Clusters::PowerSource::BatChargeStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatChargeState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatChargeState
+namespace BatTimeToFullCharge {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatTimeToFullCharge::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatTimeToFullCharge
+namespace BatFunctionalWhileCharging {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatFunctionalWhileCharging::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatFunctionalWhileCharging
+namespace BatChargingCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatChargingCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatChargingCurrent
+namespace ActiveBatChargeFaults {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatChargeFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFaultEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatChargeFaults::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveBatChargeFaults
+namespace EndpointList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::EndpointId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::EndpointId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EndpointList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EndpointList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Status::TypeInfo::DecodableType status =
+ static_cast<chip::app::Clusters::PowerSource::PowerSourceStatusEnum>(0);
+ Attributes::Order::TypeInfo::DecodableType order = static_cast<uint8_t>(0);
+ Attributes::Description::TypeInfo::DecodableType description;
+ Attributes::WiredAssessedInputVoltage::TypeInfo::DecodableType wiredAssessedInputVoltage;
+ Attributes::WiredAssessedInputFrequency::TypeInfo::DecodableType wiredAssessedInputFrequency;
+ Attributes::WiredCurrentType::TypeInfo::DecodableType wiredCurrentType =
+ static_cast<chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>(0);
+ Attributes::WiredAssessedCurrent::TypeInfo::DecodableType wiredAssessedCurrent;
+ Attributes::WiredNominalVoltage::TypeInfo::DecodableType wiredNominalVoltage = static_cast<uint32_t>(0);
+ Attributes::WiredMaximumCurrent::TypeInfo::DecodableType wiredMaximumCurrent = static_cast<uint32_t>(0);
+ Attributes::WiredPresent::TypeInfo::DecodableType wiredPresent = static_cast<bool>(0);
+ Attributes::ActiveWiredFaults::TypeInfo::DecodableType activeWiredFaults;
+ Attributes::BatVoltage::TypeInfo::DecodableType batVoltage;
+ Attributes::BatPercentRemaining::TypeInfo::DecodableType batPercentRemaining;
+ Attributes::BatTimeRemaining::TypeInfo::DecodableType batTimeRemaining;
+ Attributes::BatChargeLevel::TypeInfo::DecodableType batChargeLevel =
+ static_cast<chip::app::Clusters::PowerSource::BatChargeLevelEnum>(0);
+ Attributes::BatReplacementNeeded::TypeInfo::DecodableType batReplacementNeeded = static_cast<bool>(0);
+ Attributes::BatReplaceability::TypeInfo::DecodableType batReplaceability =
+ static_cast<chip::app::Clusters::PowerSource::BatReplaceabilityEnum>(0);
+ Attributes::BatPresent::TypeInfo::DecodableType batPresent = static_cast<bool>(0);
+ Attributes::ActiveBatFaults::TypeInfo::DecodableType activeBatFaults;
+ Attributes::BatReplacementDescription::TypeInfo::DecodableType batReplacementDescription;
+ Attributes::BatCommonDesignation::TypeInfo::DecodableType batCommonDesignation =
+ static_cast<chip::app::Clusters::PowerSource::BatCommonDesignationEnum>(0);
+ Attributes::BatANSIDesignation::TypeInfo::DecodableType batANSIDesignation;
+ Attributes::BatIECDesignation::TypeInfo::DecodableType batIECDesignation;
+ Attributes::BatApprovedChemistry::TypeInfo::DecodableType batApprovedChemistry =
+ static_cast<chip::app::Clusters::PowerSource::BatApprovedChemistryEnum>(0);
+ Attributes::BatCapacity::TypeInfo::DecodableType batCapacity = static_cast<uint32_t>(0);
+ Attributes::BatQuantity::TypeInfo::DecodableType batQuantity = static_cast<uint8_t>(0);
+ Attributes::BatChargeState::TypeInfo::DecodableType batChargeState =
+ static_cast<chip::app::Clusters::PowerSource::BatChargeStateEnum>(0);
+ Attributes::BatTimeToFullCharge::TypeInfo::DecodableType batTimeToFullCharge;
+ Attributes::BatFunctionalWhileCharging::TypeInfo::DecodableType batFunctionalWhileCharging = static_cast<bool>(0);
+ Attributes::BatChargingCurrent::TypeInfo::DecodableType batChargingCurrent;
+ Attributes::ActiveBatChargeFaults::TypeInfo::DecodableType activeBatChargeFaults;
+ Attributes::EndpointList::TypeInfo::DecodableType endpointList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace WiredFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::WiredFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const WiredFaultEnum> current;
+ DataModel::List<const WiredFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::WiredFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+
+ DataModel::DecodableList<WiredFaultEnum> current;
+ DataModel::DecodableList<WiredFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace WiredFaultChange
+namespace BatFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BatFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const BatFaultEnum> current;
+ DataModel::List<const BatFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BatFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+
+ DataModel::DecodableList<BatFaultEnum> current;
+ DataModel::DecodableList<BatFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace BatFaultChange
+namespace BatChargeFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BatChargeFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const BatChargeFaultEnum> current;
+ DataModel::List<const BatChargeFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BatChargeFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; }
+
+ DataModel::DecodableList<BatChargeFaultEnum> current;
+ DataModel::DecodableList<BatChargeFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace BatChargeFaultChange
+} // namespace Events
+} // namespace PowerSource
+namespace GeneralCommissioning {
+namespace Structs {
+namespace BasicCommissioningInfo {
+enum class Fields : uint8_t
+{
+ kFailSafeExpiryLengthSeconds = 0,
+ kMaxCumulativeFailsafeSeconds = 1,
+};
+
+struct Type
+{
+public:
+ uint16_t failSafeExpiryLengthSeconds = static_cast<uint16_t>(0);
+ uint16_t maxCumulativeFailsafeSeconds = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace BasicCommissioningInfo
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ArmFailSafe {
+struct Type;
+struct DecodableType;
+} // namespace ArmFailSafe
+
+namespace ArmFailSafeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ArmFailSafeResponse
+
+namespace SetRegulatoryConfig {
+struct Type;
+struct DecodableType;
+} // namespace SetRegulatoryConfig
+
+namespace SetRegulatoryConfigResponse {
+struct Type;
+struct DecodableType;
+} // namespace SetRegulatoryConfigResponse
+
+namespace CommissioningComplete {
+struct Type;
+struct DecodableType;
+} // namespace CommissioningComplete
+
+namespace CommissioningCompleteResponse {
+struct Type;
+struct DecodableType;
+} // namespace CommissioningCompleteResponse
+
+namespace SetTCAcknowledgements {
+struct Type;
+struct DecodableType;
+} // namespace SetTCAcknowledgements
+
+namespace SetTCAcknowledgementsResponse {
+struct Type;
+struct DecodableType;
+} // namespace SetTCAcknowledgementsResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ArmFailSafe {
+enum class Fields : uint8_t
+{
+ kExpiryLengthSeconds = 0,
+ kBreadcrumb = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ArmFailSafe::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ uint16_t expiryLengthSeconds = static_cast<uint16_t>(0);
+ uint64_t breadcrumb = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ArmFailSafe::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ uint16_t expiryLengthSeconds = static_cast<uint16_t>(0);
+ uint64_t breadcrumb = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ArmFailSafe
+namespace ArmFailSafeResponse {
+enum class Fields : uint8_t
+{
+ kErrorCode = 0,
+ kDebugText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ArmFailSafeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ chip::CharSpan debugText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ArmFailSafeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ chip::CharSpan debugText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ArmFailSafeResponse
+namespace SetRegulatoryConfig {
+enum class Fields : uint8_t
+{
+ kNewRegulatoryConfig = 0,
+ kCountryCode = 1,
+ kBreadcrumb = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfig::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ RegulatoryLocationTypeEnum newRegulatoryConfig = static_cast<RegulatoryLocationTypeEnum>(0);
+ chip::CharSpan countryCode;
+ uint64_t breadcrumb = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GeneralCommissioning::Commands::SetRegulatoryConfigResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfig::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ RegulatoryLocationTypeEnum newRegulatoryConfig = static_cast<RegulatoryLocationTypeEnum>(0);
+ chip::CharSpan countryCode;
+ uint64_t breadcrumb = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetRegulatoryConfig
+namespace SetRegulatoryConfigResponse {
+enum class Fields : uint8_t
+{
+ kErrorCode = 0,
+ kDebugText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfigResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ chip::CharSpan debugText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfigResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ chip::CharSpan debugText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetRegulatoryConfigResponse
+namespace CommissioningComplete {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CommissioningComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GeneralCommissioning::Commands::CommissioningCompleteResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CommissioningComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommissioningComplete
+namespace CommissioningCompleteResponse {
+enum class Fields : uint8_t
+{
+ kErrorCode = 0,
+ kDebugText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CommissioningCompleteResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ chip::CharSpan debugText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CommissioningCompleteResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ chip::CharSpan debugText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommissioningCompleteResponse
+namespace SetTCAcknowledgements {
+enum class Fields : uint8_t
+{
+ kTCVersion = 0,
+ kTCUserResponse = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTCAcknowledgements::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ uint16_t TCVersion = static_cast<uint16_t>(0);
+ uint16_t TCUserResponse = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GeneralCommissioning::Commands::SetTCAcknowledgementsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTCAcknowledgements::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ uint16_t TCVersion = static_cast<uint16_t>(0);
+ uint16_t TCUserResponse = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTCAcknowledgements
+namespace SetTCAcknowledgementsResponse {
+enum class Fields : uint8_t
+{
+ kErrorCode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTCAcknowledgementsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTCAcknowledgementsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CommissioningErrorEnum errorCode = static_cast<CommissioningErrorEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTCAcknowledgementsResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Breadcrumb {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Breadcrumb::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Breadcrumb
+namespace BasicCommissioningInfo {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::Type;
+ using DecodableType = chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BasicCommissioningInfo::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BasicCommissioningInfo
+namespace RegulatoryConfig {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum;
+ using DecodableType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum;
+ using DecodableArgType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RegulatoryConfig::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RegulatoryConfig
+namespace LocationCapability {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum;
+ using DecodableType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum;
+ using DecodableArgType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocationCapability::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocationCapability
+namespace SupportsConcurrentConnection {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportsConcurrentConnection::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportsConcurrentConnection
+namespace TCAcceptedVersion {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TCAcceptedVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TCAcceptedVersion
+namespace TCMinRequiredVersion {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TCMinRequiredVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TCMinRequiredVersion
+namespace TCAcknowledgements {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TCAcknowledgements::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TCAcknowledgements
+namespace TCAcknowledgementsRequired {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TCAcknowledgementsRequired::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TCAcknowledgementsRequired
+namespace TCUpdateDeadline {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TCUpdateDeadline::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TCUpdateDeadline
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Breadcrumb::TypeInfo::DecodableType breadcrumb = static_cast<uint64_t>(0);
+ Attributes::BasicCommissioningInfo::TypeInfo::DecodableType basicCommissioningInfo;
+ Attributes::RegulatoryConfig::TypeInfo::DecodableType regulatoryConfig =
+ static_cast<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum>(0);
+ Attributes::LocationCapability::TypeInfo::DecodableType locationCapability =
+ static_cast<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum>(0);
+ Attributes::SupportsConcurrentConnection::TypeInfo::DecodableType supportsConcurrentConnection = static_cast<bool>(0);
+ Attributes::TCAcceptedVersion::TypeInfo::DecodableType TCAcceptedVersion = static_cast<uint16_t>(0);
+ Attributes::TCMinRequiredVersion::TypeInfo::DecodableType TCMinRequiredVersion = static_cast<uint16_t>(0);
+ Attributes::TCAcknowledgements::TypeInfo::DecodableType TCAcknowledgements = static_cast<uint16_t>(0);
+ Attributes::TCAcknowledgementsRequired::TypeInfo::DecodableType TCAcknowledgementsRequired = static_cast<bool>(0);
+ Attributes::TCUpdateDeadline::TypeInfo::DecodableType TCUpdateDeadline = static_cast<uint32_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace GeneralCommissioning
+namespace NetworkCommissioning {
+namespace Structs {
+namespace NetworkInfoStruct {
+enum class Fields : uint8_t
+{
+ kNetworkID = 0,
+ kConnected = 1,
+ kNetworkIdentifier = 2,
+ kClientIdentifier = 3,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan networkID;
+ bool connected = static_cast<bool>(0);
+ Optional<DataModel::Nullable<chip::ByteSpan>> networkIdentifier;
+ Optional<DataModel::Nullable<chip::ByteSpan>> clientIdentifier;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace NetworkInfoStruct
+namespace ThreadInterfaceScanResultStruct {
+enum class Fields : uint8_t
+{
+ kPanId = 0,
+ kExtendedPanId = 1,
+ kNetworkName = 2,
+ kChannel = 3,
+ kVersion = 4,
+ kExtendedAddress = 5,
+ kRssi = 6,
+ kLqi = 7,
+};
+
+struct Type
+{
+public:
+ uint16_t panId = static_cast<uint16_t>(0);
+ uint64_t extendedPanId = static_cast<uint64_t>(0);
+ chip::CharSpan networkName;
+ uint16_t channel = static_cast<uint16_t>(0);
+ uint8_t version = static_cast<uint8_t>(0);
+ chip::ByteSpan extendedAddress;
+ int8_t rssi = static_cast<int8_t>(0);
+ uint8_t lqi = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ThreadInterfaceScanResultStruct
+namespace WiFiInterfaceScanResultStruct {
+enum class Fields : uint8_t
+{
+ kSecurity = 0,
+ kSsid = 1,
+ kBssid = 2,
+ kChannel = 3,
+ kWiFiBand = 4,
+ kRssi = 5,
+};
+
+struct Type
+{
+public:
+ chip::BitMask<WiFiSecurityBitmap> security = static_cast<chip::BitMask<WiFiSecurityBitmap>>(0);
+ chip::ByteSpan ssid;
+ chip::ByteSpan bssid;
+ uint16_t channel = static_cast<uint16_t>(0);
+ WiFiBandEnum wiFiBand = static_cast<WiFiBandEnum>(0);
+ int8_t rssi = static_cast<int8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace WiFiInterfaceScanResultStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ScanNetworks {
+struct Type;
+struct DecodableType;
+} // namespace ScanNetworks
+
+namespace ScanNetworksResponse {
+struct Type;
+struct DecodableType;
+} // namespace ScanNetworksResponse
+
+namespace AddOrUpdateWiFiNetwork {
+struct Type;
+struct DecodableType;
+} // namespace AddOrUpdateWiFiNetwork
+
+namespace AddOrUpdateThreadNetwork {
+struct Type;
+struct DecodableType;
+} // namespace AddOrUpdateThreadNetwork
+
+namespace RemoveNetwork {
+struct Type;
+struct DecodableType;
+} // namespace RemoveNetwork
+
+namespace NetworkConfigResponse {
+struct Type;
+struct DecodableType;
+} // namespace NetworkConfigResponse
+
+namespace ConnectNetwork {
+struct Type;
+struct DecodableType;
+} // namespace ConnectNetwork
+
+namespace ConnectNetworkResponse {
+struct Type;
+struct DecodableType;
+} // namespace ConnectNetworkResponse
+
+namespace ReorderNetwork {
+struct Type;
+struct DecodableType;
+} // namespace ReorderNetwork
+
+namespace QueryIdentity {
+struct Type;
+struct DecodableType;
+} // namespace QueryIdentity
+
+namespace QueryIdentityResponse {
+struct Type;
+struct DecodableType;
+} // namespace QueryIdentityResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ScanNetworks {
+enum class Fields : uint8_t
+{
+ kSsid = 0,
+ kBreadcrumb = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ScanNetworks::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ Optional<DataModel::Nullable<chip::ByteSpan>> ssid;
+ Optional<uint64_t> breadcrumb;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::ScanNetworksResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ScanNetworks::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ Optional<DataModel::Nullable<chip::ByteSpan>> ssid;
+ Optional<uint64_t> breadcrumb;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ScanNetworks
+namespace ScanNetworksResponse {
+enum class Fields : uint8_t
+{
+ kNetworkingStatus = 0,
+ kDebugText = 1,
+ kWiFiScanResults = 2,
+ kThreadScanResults = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ScanNetworksResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ NetworkCommissioningStatusEnum networkingStatus = static_cast<NetworkCommissioningStatusEnum>(0);
+ Optional<chip::CharSpan> debugText;
+ Optional<DataModel::List<const Structs::WiFiInterfaceScanResultStruct::Type>> wiFiScanResults;
+ Optional<DataModel::List<const Structs::ThreadInterfaceScanResultStruct::Type>> threadScanResults;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ScanNetworksResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ NetworkCommissioningStatusEnum networkingStatus = static_cast<NetworkCommissioningStatusEnum>(0);
+ Optional<chip::CharSpan> debugText;
+ Optional<DataModel::DecodableList<Structs::WiFiInterfaceScanResultStruct::DecodableType>> wiFiScanResults;
+ Optional<DataModel::DecodableList<Structs::ThreadInterfaceScanResultStruct::DecodableType>> threadScanResults;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ScanNetworksResponse
+namespace AddOrUpdateWiFiNetwork {
+enum class Fields : uint8_t
+{
+ kSsid = 0,
+ kCredentials = 1,
+ kBreadcrumb = 2,
+ kNetworkIdentity = 3,
+ kClientIdentifier = 4,
+ kPossessionNonce = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateWiFiNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan ssid;
+ chip::ByteSpan credentials;
+ Optional<uint64_t> breadcrumb;
+ Optional<chip::ByteSpan> networkIdentity;
+ Optional<chip::ByteSpan> clientIdentifier;
+ Optional<chip::ByteSpan> possessionNonce;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateWiFiNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan ssid;
+ chip::ByteSpan credentials;
+ Optional<uint64_t> breadcrumb;
+ Optional<chip::ByteSpan> networkIdentity;
+ Optional<chip::ByteSpan> clientIdentifier;
+ Optional<chip::ByteSpan> possessionNonce;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddOrUpdateWiFiNetwork
+namespace AddOrUpdateThreadNetwork {
+enum class Fields : uint8_t
+{
+ kOperationalDataset = 0,
+ kBreadcrumb = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateThreadNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan operationalDataset;
+ Optional<uint64_t> breadcrumb;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateThreadNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan operationalDataset;
+ Optional<uint64_t> breadcrumb;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddOrUpdateThreadNetwork
+namespace RemoveNetwork {
+enum class Fields : uint8_t
+{
+ kNetworkID = 0,
+ kBreadcrumb = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan networkID;
+ Optional<uint64_t> breadcrumb;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan networkID;
+ Optional<uint64_t> breadcrumb;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveNetwork
+namespace NetworkConfigResponse {
+enum class Fields : uint8_t
+{
+ kNetworkingStatus = 0,
+ kDebugText = 1,
+ kNetworkIndex = 2,
+ kClientIdentity = 3,
+ kPossessionSignature = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NetworkConfigResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ NetworkCommissioningStatusEnum networkingStatus = static_cast<NetworkCommissioningStatusEnum>(0);
+ Optional<chip::CharSpan> debugText;
+ Optional<uint8_t> networkIndex;
+ Optional<chip::ByteSpan> clientIdentity;
+ Optional<chip::ByteSpan> possessionSignature;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NetworkConfigResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ NetworkCommissioningStatusEnum networkingStatus = static_cast<NetworkCommissioningStatusEnum>(0);
+ Optional<chip::CharSpan> debugText;
+ Optional<uint8_t> networkIndex;
+ Optional<chip::ByteSpan> clientIdentity;
+ Optional<chip::ByteSpan> possessionSignature;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NetworkConfigResponse
+namespace ConnectNetwork {
+enum class Fields : uint8_t
+{
+ kNetworkID = 0,
+ kBreadcrumb = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ConnectNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan networkID;
+ Optional<uint64_t> breadcrumb;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ConnectNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan networkID;
+ Optional<uint64_t> breadcrumb;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ConnectNetwork
+namespace ConnectNetworkResponse {
+enum class Fields : uint8_t
+{
+ kNetworkingStatus = 0,
+ kDebugText = 1,
+ kErrorValue = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ConnectNetworkResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ NetworkCommissioningStatusEnum networkingStatus = static_cast<NetworkCommissioningStatusEnum>(0);
+ Optional<chip::CharSpan> debugText;
+ DataModel::Nullable<int32_t> errorValue;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ConnectNetworkResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ NetworkCommissioningStatusEnum networkingStatus = static_cast<NetworkCommissioningStatusEnum>(0);
+ Optional<chip::CharSpan> debugText;
+ DataModel::Nullable<int32_t> errorValue;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ConnectNetworkResponse
+namespace ReorderNetwork {
+enum class Fields : uint8_t
+{
+ kNetworkID = 0,
+ kNetworkIndex = 1,
+ kBreadcrumb = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ReorderNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan networkID;
+ uint8_t networkIndex = static_cast<uint8_t>(0);
+ Optional<uint64_t> breadcrumb;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ReorderNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan networkID;
+ uint8_t networkIndex = static_cast<uint8_t>(0);
+ Optional<uint64_t> breadcrumb;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ReorderNetwork
+namespace QueryIdentity {
+enum class Fields : uint8_t
+{
+ kKeyIdentifier = 0,
+ kPossessionNonce = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::QueryIdentity::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan keyIdentifier;
+ Optional<chip::ByteSpan> possessionNonce;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::NetworkCommissioning::Commands::QueryIdentityResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::QueryIdentity::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan keyIdentifier;
+ Optional<chip::ByteSpan> possessionNonce;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace QueryIdentity
+namespace QueryIdentityResponse {
+enum class Fields : uint8_t
+{
+ kIdentity = 0,
+ kPossessionSignature = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::QueryIdentityResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan identity;
+ Optional<chip::ByteSpan> possessionSignature;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::QueryIdentityResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ chip::ByteSpan identity;
+ Optional<chip::ByteSpan> possessionSignature;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace QueryIdentityResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace MaxNetworks {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxNetworks::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxNetworks
+namespace Networks {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfoStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfoStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Networks::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Networks
+namespace ScanMaxTimeSeconds {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScanMaxTimeSeconds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScanMaxTimeSeconds
+namespace ConnectMaxTimeSeconds {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ConnectMaxTimeSeconds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ConnectMaxTimeSeconds
+namespace InterfaceEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InterfaceEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InterfaceEnabled
+namespace LastNetworkingStatus {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LastNetworkingStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LastNetworkingStatus
+namespace LastNetworkID {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LastNetworkID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace LastNetworkID
+namespace LastConnectErrorValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LastConnectErrorValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LastConnectErrorValue
+namespace SupportedWiFiBands {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::NetworkCommissioning::WiFiBandEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::WiFiBandEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::WiFiBandEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedWiFiBands::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedWiFiBands
+namespace SupportedThreadFeatures {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedThreadFeatures::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedThreadFeatures
+namespace ThreadVersion {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThreadVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThreadVersion
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MaxNetworks::TypeInfo::DecodableType maxNetworks = static_cast<uint8_t>(0);
+ Attributes::Networks::TypeInfo::DecodableType networks;
+ Attributes::ScanMaxTimeSeconds::TypeInfo::DecodableType scanMaxTimeSeconds = static_cast<uint8_t>(0);
+ Attributes::ConnectMaxTimeSeconds::TypeInfo::DecodableType connectMaxTimeSeconds = static_cast<uint8_t>(0);
+ Attributes::InterfaceEnabled::TypeInfo::DecodableType interfaceEnabled = static_cast<bool>(0);
+ Attributes::LastNetworkingStatus::TypeInfo::DecodableType lastNetworkingStatus;
+ Attributes::LastNetworkID::TypeInfo::DecodableType lastNetworkID;
+ Attributes::LastConnectErrorValue::TypeInfo::DecodableType lastConnectErrorValue;
+ Attributes::SupportedWiFiBands::TypeInfo::DecodableType supportedWiFiBands;
+ Attributes::SupportedThreadFeatures::TypeInfo::DecodableType supportedThreadFeatures =
+ static_cast<chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>>(0);
+ Attributes::ThreadVersion::TypeInfo::DecodableType threadVersion = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace NetworkCommissioning
+namespace DiagnosticLogs {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace RetrieveLogsRequest {
+struct Type;
+struct DecodableType;
+} // namespace RetrieveLogsRequest
+
+namespace RetrieveLogsResponse {
+struct Type;
+struct DecodableType;
+} // namespace RetrieveLogsResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace RetrieveLogsRequest {
+enum class Fields : uint8_t
+{
+ kIntent = 0,
+ kRequestedProtocol = 1,
+ kTransferFileDesignator = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+
+ IntentEnum intent = static_cast<IntentEnum>(0);
+ TransferProtocolEnum requestedProtocol = static_cast<TransferProtocolEnum>(0);
+ Optional<chip::CharSpan> transferFileDesignator;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+
+ IntentEnum intent = static_cast<IntentEnum>(0);
+ TransferProtocolEnum requestedProtocol = static_cast<TransferProtocolEnum>(0);
+ Optional<chip::CharSpan> transferFileDesignator;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RetrieveLogsRequest
+namespace RetrieveLogsResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kLogContent = 1,
+ kUTCTimeStamp = 2,
+ kTimeSinceBoot = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ chip::ByteSpan logContent;
+ Optional<uint64_t> UTCTimeStamp;
+ Optional<uint64_t> timeSinceBoot;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ chip::ByteSpan logContent;
+ Optional<uint64_t> UTCTimeStamp;
+ Optional<uint64_t> timeSinceBoot;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RetrieveLogsResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace DiagnosticLogs
+namespace GeneralDiagnostics {
+namespace Structs {
+namespace NetworkInterface {
+enum class Fields : uint8_t
+{
+ kName = 0,
+ kIsOperational = 1,
+ kOffPremiseServicesReachableIPv4 = 2,
+ kOffPremiseServicesReachableIPv6 = 3,
+ kHardwareAddress = 4,
+ kIPv4Addresses = 5,
+ kIPv6Addresses = 6,
+ kType = 7,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan name;
+ bool isOperational = static_cast<bool>(0);
+ DataModel::Nullable<bool> offPremiseServicesReachableIPv4;
+ DataModel::Nullable<bool> offPremiseServicesReachableIPv6;
+ chip::ByteSpan hardwareAddress;
+ DataModel::List<const chip::ByteSpan> IPv4Addresses;
+ DataModel::List<const chip::ByteSpan> IPv6Addresses;
+ InterfaceTypeEnum type = static_cast<InterfaceTypeEnum>(0);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::CharSpan name;
+ bool isOperational = static_cast<bool>(0);
+ DataModel::Nullable<bool> offPremiseServicesReachableIPv4;
+ DataModel::Nullable<bool> offPremiseServicesReachableIPv6;
+ chip::ByteSpan hardwareAddress;
+ DataModel::DecodableList<chip::ByteSpan> IPv4Addresses;
+ DataModel::DecodableList<chip::ByteSpan> IPv6Addresses;
+ InterfaceTypeEnum type = static_cast<InterfaceTypeEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace NetworkInterface
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace TestEventTrigger {
+struct Type;
+struct DecodableType;
+} // namespace TestEventTrigger
+
+namespace TimeSnapshot {
+struct Type;
+struct DecodableType;
+} // namespace TimeSnapshot
+
+namespace TimeSnapshotResponse {
+struct Type;
+struct DecodableType;
+} // namespace TimeSnapshotResponse
+
+namespace PayloadTestRequest {
+struct Type;
+struct DecodableType;
+} // namespace PayloadTestRequest
+
+namespace PayloadTestResponse {
+struct Type;
+struct DecodableType;
+} // namespace PayloadTestResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace TestEventTrigger {
+enum class Fields : uint8_t
+{
+ kEnableKey = 0,
+ kEventTrigger = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEventTrigger::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ chip::ByteSpan enableKey;
+ uint64_t eventTrigger = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEventTrigger::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ chip::ByteSpan enableKey;
+ uint64_t eventTrigger = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEventTrigger
+namespace TimeSnapshot {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TimeSnapshot::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GeneralDiagnostics::Commands::TimeSnapshotResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TimeSnapshot::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TimeSnapshot
+namespace TimeSnapshotResponse {
+enum class Fields : uint8_t
+{
+ kSystemTimeMs = 0,
+ kPosixTimeMs = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TimeSnapshotResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ uint64_t systemTimeMs = static_cast<uint64_t>(0);
+ DataModel::Nullable<uint64_t> posixTimeMs;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TimeSnapshotResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ uint64_t systemTimeMs = static_cast<uint64_t>(0);
+ DataModel::Nullable<uint64_t> posixTimeMs;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TimeSnapshotResponse
+namespace PayloadTestRequest {
+enum class Fields : uint8_t
+{
+ kEnableKey = 0,
+ kValue = 1,
+ kCount = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PayloadTestRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ chip::ByteSpan enableKey;
+ uint8_t value = static_cast<uint8_t>(0);
+ uint16_t count = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GeneralDiagnostics::Commands::PayloadTestResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PayloadTestRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ chip::ByteSpan enableKey;
+ uint8_t value = static_cast<uint8_t>(0);
+ uint16_t count = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PayloadTestRequest
+namespace PayloadTestResponse {
+enum class Fields : uint8_t
+{
+ kPayload = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PayloadTestResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ chip::ByteSpan payload;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PayloadTestResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ chip::ByteSpan payload;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PayloadTestResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace NetworkInterfaces {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterface::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterface::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterface::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NetworkInterfaces::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NetworkInterfaces
+namespace RebootCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RebootCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RebootCount
+namespace UpTime {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UpTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UpTime
+namespace TotalOperationalHours {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TotalOperationalHours::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TotalOperationalHours
+namespace BootReason {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::GeneralDiagnostics::BootReasonEnum;
+ using DecodableType = chip::app::Clusters::GeneralDiagnostics::BootReasonEnum;
+ using DecodableArgType = chip::app::Clusters::GeneralDiagnostics::BootReasonEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BootReason::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BootReason
+namespace ActiveHardwareFaults {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::HardwareFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::HardwareFaultEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::HardwareFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveHardwareFaults::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveHardwareFaults
+namespace ActiveRadioFaults {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::RadioFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::RadioFaultEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::RadioFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveRadioFaults::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveRadioFaults
+namespace ActiveNetworkFaults {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::NetworkFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::NetworkFaultEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::NetworkFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaults::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveNetworkFaults
+namespace TestEventTriggersEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TestEventTriggersEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TestEventTriggersEnabled
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::NetworkInterfaces::TypeInfo::DecodableType networkInterfaces;
+ Attributes::RebootCount::TypeInfo::DecodableType rebootCount = static_cast<uint16_t>(0);
+ Attributes::UpTime::TypeInfo::DecodableType upTime = static_cast<uint64_t>(0);
+ Attributes::TotalOperationalHours::TypeInfo::DecodableType totalOperationalHours = static_cast<uint32_t>(0);
+ Attributes::BootReason::TypeInfo::DecodableType bootReason =
+ static_cast<chip::app::Clusters::GeneralDiagnostics::BootReasonEnum>(0);
+ Attributes::ActiveHardwareFaults::TypeInfo::DecodableType activeHardwareFaults;
+ Attributes::ActiveRadioFaults::TypeInfo::DecodableType activeRadioFaults;
+ Attributes::ActiveNetworkFaults::TypeInfo::DecodableType activeNetworkFaults;
+ Attributes::TestEventTriggersEnabled::TypeInfo::DecodableType testEventTriggersEnabled = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace HardwareFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::HardwareFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const HardwareFaultEnum> current;
+ DataModel::List<const HardwareFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::HardwareFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ DataModel::DecodableList<HardwareFaultEnum> current;
+ DataModel::DecodableList<HardwareFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace HardwareFaultChange
+namespace RadioFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::RadioFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const RadioFaultEnum> current;
+ DataModel::List<const RadioFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::RadioFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ DataModel::DecodableList<RadioFaultEnum> current;
+ DataModel::DecodableList<RadioFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace RadioFaultChange
+namespace NetworkFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const NetworkFaultEnum> current;
+ DataModel::List<const NetworkFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ DataModel::DecodableList<NetworkFaultEnum> current;
+ DataModel::DecodableList<NetworkFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace NetworkFaultChange
+namespace BootReason {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kBootReason = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BootReason::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ BootReasonEnum bootReason = static_cast<BootReasonEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BootReason::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; }
+
+ BootReasonEnum bootReason = static_cast<BootReasonEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace BootReason
+} // namespace Events
+} // namespace GeneralDiagnostics
+namespace SoftwareDiagnostics {
+namespace Structs {
+namespace ThreadMetricsStruct {
+enum class Fields : uint8_t
+{
+ kId = 0,
+ kName = 1,
+ kStackFreeCurrent = 2,
+ kStackFreeMinimum = 3,
+ kStackSize = 4,
+};
+
+struct Type
+{
+public:
+ uint64_t id = static_cast<uint64_t>(0);
+ Optional<chip::CharSpan> name;
+ Optional<uint32_t> stackFreeCurrent;
+ Optional<uint32_t> stackFreeMinimum;
+ Optional<uint32_t> stackSize;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ThreadMetricsStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ResetWatermarks {
+struct Type;
+struct DecodableType;
+} // namespace ResetWatermarks
+
+} // namespace Commands
+
+namespace Commands {
+namespace ResetWatermarks {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetWatermarks::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetWatermarks::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetWatermarks
+} // namespace Commands
+
+namespace Attributes {
+
+namespace ThreadMetrics {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThreadMetrics::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThreadMetrics
+namespace CurrentHeapFree {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapFree::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentHeapFree
+namespace CurrentHeapUsed {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapUsed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentHeapUsed
+namespace CurrentHeapHighWatermark {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapHighWatermark::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentHeapHighWatermark
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::ThreadMetrics::TypeInfo::DecodableType threadMetrics;
+ Attributes::CurrentHeapFree::TypeInfo::DecodableType currentHeapFree = static_cast<uint64_t>(0);
+ Attributes::CurrentHeapUsed::TypeInfo::DecodableType currentHeapUsed = static_cast<uint64_t>(0);
+ Attributes::CurrentHeapHighWatermark::TypeInfo::DecodableType currentHeapHighWatermark = static_cast<uint64_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace SoftwareFault {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kId = 0,
+ kName = 1,
+ kFaultRecording = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SoftwareFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint64_t id = static_cast<uint64_t>(0);
+ Optional<chip::CharSpan> name;
+ Optional<chip::ByteSpan> faultRecording;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SoftwareFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; }
+
+ uint64_t id = static_cast<uint64_t>(0);
+ Optional<chip::CharSpan> name;
+ Optional<chip::ByteSpan> faultRecording;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SoftwareFault
+} // namespace Events
+} // namespace SoftwareDiagnostics
+namespace ThreadNetworkDiagnostics {
+namespace Structs {
+namespace NeighborTableStruct {
+enum class Fields : uint8_t
+{
+ kExtAddress = 0,
+ kAge = 1,
+ kRloc16 = 2,
+ kLinkFrameCounter = 3,
+ kMleFrameCounter = 4,
+ kLqi = 5,
+ kAverageRssi = 6,
+ kLastRssi = 7,
+ kFrameErrorRate = 8,
+ kMessageErrorRate = 9,
+ kRxOnWhenIdle = 10,
+ kFullThreadDevice = 11,
+ kFullNetworkData = 12,
+ kIsChild = 13,
+};
+
+struct Type
+{
+public:
+ uint64_t extAddress = static_cast<uint64_t>(0);
+ uint32_t age = static_cast<uint32_t>(0);
+ uint16_t rloc16 = static_cast<uint16_t>(0);
+ uint32_t linkFrameCounter = static_cast<uint32_t>(0);
+ uint32_t mleFrameCounter = static_cast<uint32_t>(0);
+ uint8_t lqi = static_cast<uint8_t>(0);
+ DataModel::Nullable<int8_t> averageRssi;
+ DataModel::Nullable<int8_t> lastRssi;
+ uint8_t frameErrorRate = static_cast<uint8_t>(0);
+ uint8_t messageErrorRate = static_cast<uint8_t>(0);
+ bool rxOnWhenIdle = static_cast<bool>(0);
+ bool fullThreadDevice = static_cast<bool>(0);
+ bool fullNetworkData = static_cast<bool>(0);
+ bool isChild = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace NeighborTableStruct
+namespace OperationalDatasetComponents {
+enum class Fields : uint8_t
+{
+ kActiveTimestampPresent = 0,
+ kPendingTimestampPresent = 1,
+ kMasterKeyPresent = 2,
+ kNetworkNamePresent = 3,
+ kExtendedPanIdPresent = 4,
+ kMeshLocalPrefixPresent = 5,
+ kDelayPresent = 6,
+ kPanIdPresent = 7,
+ kChannelPresent = 8,
+ kPskcPresent = 9,
+ kSecurityPolicyPresent = 10,
+ kChannelMaskPresent = 11,
+};
+
+struct Type
+{
+public:
+ bool activeTimestampPresent = static_cast<bool>(0);
+ bool pendingTimestampPresent = static_cast<bool>(0);
+ bool masterKeyPresent = static_cast<bool>(0);
+ bool networkNamePresent = static_cast<bool>(0);
+ bool extendedPanIdPresent = static_cast<bool>(0);
+ bool meshLocalPrefixPresent = static_cast<bool>(0);
+ bool delayPresent = static_cast<bool>(0);
+ bool panIdPresent = static_cast<bool>(0);
+ bool channelPresent = static_cast<bool>(0);
+ bool pskcPresent = static_cast<bool>(0);
+ bool securityPolicyPresent = static_cast<bool>(0);
+ bool channelMaskPresent = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace OperationalDatasetComponents
+namespace RouteTableStruct {
+enum class Fields : uint8_t
+{
+ kExtAddress = 0,
+ kRloc16 = 1,
+ kRouterId = 2,
+ kNextHop = 3,
+ kPathCost = 4,
+ kLQIIn = 5,
+ kLQIOut = 6,
+ kAge = 7,
+ kAllocated = 8,
+ kLinkEstablished = 9,
+};
+
+struct Type
+{
+public:
+ uint64_t extAddress = static_cast<uint64_t>(0);
+ uint16_t rloc16 = static_cast<uint16_t>(0);
+ uint8_t routerId = static_cast<uint8_t>(0);
+ uint8_t nextHop = static_cast<uint8_t>(0);
+ uint8_t pathCost = static_cast<uint8_t>(0);
+ uint8_t LQIIn = static_cast<uint8_t>(0);
+ uint8_t LQIOut = static_cast<uint8_t>(0);
+ uint8_t age = static_cast<uint8_t>(0);
+ bool allocated = static_cast<bool>(0);
+ bool linkEstablished = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace RouteTableStruct
+namespace SecurityPolicy {
+enum class Fields : uint8_t
+{
+ kRotationTime = 0,
+ kFlags = 1,
+};
+
+struct Type
+{
+public:
+ uint16_t rotationTime = static_cast<uint16_t>(0);
+ uint16_t flags = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SecurityPolicy
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ResetCounts {
+struct Type;
+struct DecodableType;
+} // namespace ResetCounts
+
+} // namespace Commands
+
+namespace Commands {
+namespace ResetCounts {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetCounts::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetCounts::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCounts
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Channel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Channel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Channel
+namespace RoutingRole {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRoleEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRoleEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRoleEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RoutingRole::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RoutingRole
+namespace NetworkName {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NetworkName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace NetworkName
+namespace PanId {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PanId::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PanId
+namespace ExtendedPanId {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ExtendedPanId::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ExtendedPanId
+namespace MeshLocalPrefix {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeshLocalPrefix::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 17; }
+};
+} // namespace MeshLocalPrefix
+namespace OverrunCount {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OverrunCount
+namespace NeighborTable {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTableStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTableStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTableStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NeighborTable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NeighborTable
+namespace RouteTable {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTableStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTableStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTableStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RouteTable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RouteTable
+namespace PartitionId {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PartitionId::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PartitionId
+namespace Weighting {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Weighting::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Weighting
+namespace DataVersion {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DataVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DataVersion
+namespace StableDataVersion {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StableDataVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StableDataVersion
+namespace LeaderRouterId {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LeaderRouterId::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LeaderRouterId
+namespace DetachedRoleCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DetachedRoleCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DetachedRoleCount
+namespace ChildRoleCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChildRoleCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ChildRoleCount
+namespace RouterRoleCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RouterRoleCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RouterRoleCount
+namespace LeaderRoleCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LeaderRoleCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LeaderRoleCount
+namespace AttachAttemptCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AttachAttemptCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AttachAttemptCount
+namespace PartitionIdChangeCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PartitionIdChangeCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PartitionIdChangeCount
+namespace BetterPartitionAttachAttemptCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BetterPartitionAttachAttemptCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BetterPartitionAttachAttemptCount
+namespace ParentChangeCount {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ParentChangeCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ParentChangeCount
+namespace TxTotalCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxTotalCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxTotalCount
+namespace TxUnicastCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxUnicastCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxUnicastCount
+namespace TxBroadcastCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxBroadcastCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxBroadcastCount
+namespace TxAckRequestedCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxAckRequestedCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxAckRequestedCount
+namespace TxAckedCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxAckedCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxAckedCount
+namespace TxNoAckRequestedCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxNoAckRequestedCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxNoAckRequestedCount
+namespace TxDataCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxDataCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxDataCount
+namespace TxDataPollCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxDataPollCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxDataPollCount
+namespace TxBeaconCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxBeaconCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxBeaconCount
+namespace TxBeaconRequestCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxBeaconRequestCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxBeaconRequestCount
+namespace TxOtherCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxOtherCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxOtherCount
+namespace TxRetryCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxRetryCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxRetryCount
+namespace TxDirectMaxRetryExpiryCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxDirectMaxRetryExpiryCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxDirectMaxRetryExpiryCount
+namespace TxIndirectMaxRetryExpiryCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxIndirectMaxRetryExpiryCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxIndirectMaxRetryExpiryCount
+namespace TxErrCcaCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxErrCcaCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxErrCcaCount
+namespace TxErrAbortCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxErrAbortCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxErrAbortCount
+namespace TxErrBusyChannelCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxErrBusyChannelCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxErrBusyChannelCount
+namespace RxTotalCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxTotalCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxTotalCount
+namespace RxUnicastCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxUnicastCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxUnicastCount
+namespace RxBroadcastCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxBroadcastCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxBroadcastCount
+namespace RxDataCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxDataCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxDataCount
+namespace RxDataPollCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxDataPollCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxDataPollCount
+namespace RxBeaconCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxBeaconCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxBeaconCount
+namespace RxBeaconRequestCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxBeaconRequestCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxBeaconRequestCount
+namespace RxOtherCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxOtherCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxOtherCount
+namespace RxAddressFilteredCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxAddressFilteredCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxAddressFilteredCount
+namespace RxDestAddrFilteredCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxDestAddrFilteredCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxDestAddrFilteredCount
+namespace RxDuplicatedCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxDuplicatedCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxDuplicatedCount
+namespace RxErrNoFrameCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxErrNoFrameCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxErrNoFrameCount
+namespace RxErrUnknownNeighborCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxErrUnknownNeighborCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxErrUnknownNeighborCount
+namespace RxErrInvalidSrcAddrCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxErrInvalidSrcAddrCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxErrInvalidSrcAddrCount
+namespace RxErrSecCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxErrSecCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxErrSecCount
+namespace RxErrFcsCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxErrFcsCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxErrFcsCount
+namespace RxErrOtherCount {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RxErrOtherCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RxErrOtherCount
+namespace ActiveTimestamp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveTimestamp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveTimestamp
+namespace PendingTimestamp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PendingTimestamp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PendingTimestamp
+namespace Delay {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Delay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Delay
+namespace SecurityPolicy {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::Type>;
+ using DecodableType =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SecurityPolicy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SecurityPolicy
+namespace ChannelPage0Mask {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChannelPage0Mask::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 4; }
+};
+} // namespace ChannelPage0Mask
+namespace OperationalDatasetComponents {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalDatasetComponents::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalDatasetComponents
+namespace ActiveNetworkFaultsList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFaultEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFaultEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFaultEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaultsList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveNetworkFaultsList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Channel::TypeInfo::DecodableType channel;
+ Attributes::RoutingRole::TypeInfo::DecodableType routingRole;
+ Attributes::NetworkName::TypeInfo::DecodableType networkName;
+ Attributes::PanId::TypeInfo::DecodableType panId;
+ Attributes::ExtendedPanId::TypeInfo::DecodableType extendedPanId;
+ Attributes::MeshLocalPrefix::TypeInfo::DecodableType meshLocalPrefix;
+ Attributes::OverrunCount::TypeInfo::DecodableType overrunCount = static_cast<uint64_t>(0);
+ Attributes::NeighborTable::TypeInfo::DecodableType neighborTable;
+ Attributes::RouteTable::TypeInfo::DecodableType routeTable;
+ Attributes::PartitionId::TypeInfo::DecodableType partitionId;
+ Attributes::Weighting::TypeInfo::DecodableType weighting;
+ Attributes::DataVersion::TypeInfo::DecodableType dataVersion;
+ Attributes::StableDataVersion::TypeInfo::DecodableType stableDataVersion;
+ Attributes::LeaderRouterId::TypeInfo::DecodableType leaderRouterId;
+ Attributes::DetachedRoleCount::TypeInfo::DecodableType detachedRoleCount = static_cast<uint16_t>(0);
+ Attributes::ChildRoleCount::TypeInfo::DecodableType childRoleCount = static_cast<uint16_t>(0);
+ Attributes::RouterRoleCount::TypeInfo::DecodableType routerRoleCount = static_cast<uint16_t>(0);
+ Attributes::LeaderRoleCount::TypeInfo::DecodableType leaderRoleCount = static_cast<uint16_t>(0);
+ Attributes::AttachAttemptCount::TypeInfo::DecodableType attachAttemptCount = static_cast<uint16_t>(0);
+ Attributes::PartitionIdChangeCount::TypeInfo::DecodableType partitionIdChangeCount = static_cast<uint16_t>(0);
+ Attributes::BetterPartitionAttachAttemptCount::TypeInfo::DecodableType betterPartitionAttachAttemptCount =
+ static_cast<uint16_t>(0);
+ Attributes::ParentChangeCount::TypeInfo::DecodableType parentChangeCount = static_cast<uint16_t>(0);
+ Attributes::TxTotalCount::TypeInfo::DecodableType txTotalCount = static_cast<uint32_t>(0);
+ Attributes::TxUnicastCount::TypeInfo::DecodableType txUnicastCount = static_cast<uint32_t>(0);
+ Attributes::TxBroadcastCount::TypeInfo::DecodableType txBroadcastCount = static_cast<uint32_t>(0);
+ Attributes::TxAckRequestedCount::TypeInfo::DecodableType txAckRequestedCount = static_cast<uint32_t>(0);
+ Attributes::TxAckedCount::TypeInfo::DecodableType txAckedCount = static_cast<uint32_t>(0);
+ Attributes::TxNoAckRequestedCount::TypeInfo::DecodableType txNoAckRequestedCount = static_cast<uint32_t>(0);
+ Attributes::TxDataCount::TypeInfo::DecodableType txDataCount = static_cast<uint32_t>(0);
+ Attributes::TxDataPollCount::TypeInfo::DecodableType txDataPollCount = static_cast<uint32_t>(0);
+ Attributes::TxBeaconCount::TypeInfo::DecodableType txBeaconCount = static_cast<uint32_t>(0);
+ Attributes::TxBeaconRequestCount::TypeInfo::DecodableType txBeaconRequestCount = static_cast<uint32_t>(0);
+ Attributes::TxOtherCount::TypeInfo::DecodableType txOtherCount = static_cast<uint32_t>(0);
+ Attributes::TxRetryCount::TypeInfo::DecodableType txRetryCount = static_cast<uint32_t>(0);
+ Attributes::TxDirectMaxRetryExpiryCount::TypeInfo::DecodableType txDirectMaxRetryExpiryCount = static_cast<uint32_t>(0);
+ Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo::DecodableType txIndirectMaxRetryExpiryCount = static_cast<uint32_t>(0);
+ Attributes::TxErrCcaCount::TypeInfo::DecodableType txErrCcaCount = static_cast<uint32_t>(0);
+ Attributes::TxErrAbortCount::TypeInfo::DecodableType txErrAbortCount = static_cast<uint32_t>(0);
+ Attributes::TxErrBusyChannelCount::TypeInfo::DecodableType txErrBusyChannelCount = static_cast<uint32_t>(0);
+ Attributes::RxTotalCount::TypeInfo::DecodableType rxTotalCount = static_cast<uint32_t>(0);
+ Attributes::RxUnicastCount::TypeInfo::DecodableType rxUnicastCount = static_cast<uint32_t>(0);
+ Attributes::RxBroadcastCount::TypeInfo::DecodableType rxBroadcastCount = static_cast<uint32_t>(0);
+ Attributes::RxDataCount::TypeInfo::DecodableType rxDataCount = static_cast<uint32_t>(0);
+ Attributes::RxDataPollCount::TypeInfo::DecodableType rxDataPollCount = static_cast<uint32_t>(0);
+ Attributes::RxBeaconCount::TypeInfo::DecodableType rxBeaconCount = static_cast<uint32_t>(0);
+ Attributes::RxBeaconRequestCount::TypeInfo::DecodableType rxBeaconRequestCount = static_cast<uint32_t>(0);
+ Attributes::RxOtherCount::TypeInfo::DecodableType rxOtherCount = static_cast<uint32_t>(0);
+ Attributes::RxAddressFilteredCount::TypeInfo::DecodableType rxAddressFilteredCount = static_cast<uint32_t>(0);
+ Attributes::RxDestAddrFilteredCount::TypeInfo::DecodableType rxDestAddrFilteredCount = static_cast<uint32_t>(0);
+ Attributes::RxDuplicatedCount::TypeInfo::DecodableType rxDuplicatedCount = static_cast<uint32_t>(0);
+ Attributes::RxErrNoFrameCount::TypeInfo::DecodableType rxErrNoFrameCount = static_cast<uint32_t>(0);
+ Attributes::RxErrUnknownNeighborCount::TypeInfo::DecodableType rxErrUnknownNeighborCount = static_cast<uint32_t>(0);
+ Attributes::RxErrInvalidSrcAddrCount::TypeInfo::DecodableType rxErrInvalidSrcAddrCount = static_cast<uint32_t>(0);
+ Attributes::RxErrSecCount::TypeInfo::DecodableType rxErrSecCount = static_cast<uint32_t>(0);
+ Attributes::RxErrFcsCount::TypeInfo::DecodableType rxErrFcsCount = static_cast<uint32_t>(0);
+ Attributes::RxErrOtherCount::TypeInfo::DecodableType rxErrOtherCount = static_cast<uint32_t>(0);
+ Attributes::ActiveTimestamp::TypeInfo::DecodableType activeTimestamp;
+ Attributes::PendingTimestamp::TypeInfo::DecodableType pendingTimestamp;
+ Attributes::Delay::TypeInfo::DecodableType delay;
+ Attributes::SecurityPolicy::TypeInfo::DecodableType securityPolicy;
+ Attributes::ChannelPage0Mask::TypeInfo::DecodableType channelPage0Mask;
+ Attributes::OperationalDatasetComponents::TypeInfo::DecodableType operationalDatasetComponents;
+ Attributes::ActiveNetworkFaultsList::TypeInfo::DecodableType activeNetworkFaultsList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace ConnectionStatus {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kConnectionStatus = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ ConnectionStatusEnum connectionStatus = static_cast<ConnectionStatusEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+
+ ConnectionStatusEnum connectionStatus = static_cast<ConnectionStatusEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ConnectionStatus
+namespace NetworkFaultChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCurrent = 0,
+ kPrevious = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const NetworkFaultEnum> current;
+ DataModel::List<const NetworkFaultEnum> previous;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; }
+
+ DataModel::DecodableList<NetworkFaultEnum> current;
+ DataModel::DecodableList<NetworkFaultEnum> previous;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace NetworkFaultChange
+} // namespace Events
+} // namespace ThreadNetworkDiagnostics
+namespace WiFiNetworkDiagnostics {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ResetCounts {
+struct Type;
+struct DecodableType;
+} // namespace ResetCounts
+
+} // namespace Commands
+
+namespace Commands {
+namespace ResetCounts {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetCounts::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetCounts::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCounts
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Bssid {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Bssid::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 6; }
+};
+} // namespace Bssid
+namespace SecurityType {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityTypeEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityTypeEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityTypeEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SecurityType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SecurityType
+namespace WiFiVersion {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WiFiVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WiFiVersion
+namespace ChannelNumber {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChannelNumber::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ChannelNumber
+namespace Rssi {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Rssi::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Rssi
+namespace BeaconLostCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BeaconLostCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BeaconLostCount
+namespace BeaconRxCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BeaconRxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BeaconRxCount
+namespace PacketMulticastRxCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PacketMulticastRxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PacketMulticastRxCount
+namespace PacketMulticastTxCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PacketMulticastTxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PacketMulticastTxCount
+namespace PacketUnicastRxCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PacketUnicastRxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PacketUnicastRxCount
+namespace PacketUnicastTxCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PacketUnicastTxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PacketUnicastTxCount
+namespace CurrentMaxRate {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMaxRate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMaxRate
+namespace OverrunCount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OverrunCount
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Bssid::TypeInfo::DecodableType bssid;
+ Attributes::SecurityType::TypeInfo::DecodableType securityType;
+ Attributes::WiFiVersion::TypeInfo::DecodableType wiFiVersion;
+ Attributes::ChannelNumber::TypeInfo::DecodableType channelNumber;
+ Attributes::Rssi::TypeInfo::DecodableType rssi;
+ Attributes::BeaconLostCount::TypeInfo::DecodableType beaconLostCount;
+ Attributes::BeaconRxCount::TypeInfo::DecodableType beaconRxCount;
+ Attributes::PacketMulticastRxCount::TypeInfo::DecodableType packetMulticastRxCount;
+ Attributes::PacketMulticastTxCount::TypeInfo::DecodableType packetMulticastTxCount;
+ Attributes::PacketUnicastRxCount::TypeInfo::DecodableType packetUnicastRxCount;
+ Attributes::PacketUnicastTxCount::TypeInfo::DecodableType packetUnicastTxCount;
+ Attributes::CurrentMaxRate::TypeInfo::DecodableType currentMaxRate;
+ Attributes::OverrunCount::TypeInfo::DecodableType overrunCount;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace Disconnection {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kReasonCode = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Disconnection::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint16_t reasonCode = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Disconnection::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+
+ uint16_t reasonCode = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Disconnection
+namespace AssociationFailure {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kAssociationFailureCause = 0,
+ kStatus = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AssociationFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AssociationFailureCauseEnum associationFailureCause = static_cast<AssociationFailureCauseEnum>(0);
+ uint16_t status = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AssociationFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+
+ AssociationFailureCauseEnum associationFailureCause = static_cast<AssociationFailureCauseEnum>(0);
+ uint16_t status = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AssociationFailure
+namespace ConnectionStatus {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kConnectionStatus = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ ConnectionStatusEnum connectionStatus = static_cast<ConnectionStatusEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; }
+
+ ConnectionStatusEnum connectionStatus = static_cast<ConnectionStatusEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ConnectionStatus
+} // namespace Events
+} // namespace WiFiNetworkDiagnostics
+namespace EthernetNetworkDiagnostics {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ResetCounts {
+struct Type;
+struct DecodableType;
+} // namespace ResetCounts
+
+} // namespace Commands
+
+namespace Commands {
+namespace ResetCounts {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetCounts::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetCounts::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCounts
+} // namespace Commands
+
+namespace Attributes {
+
+namespace PHYRate {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PHYRate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PHYRate
+namespace FullDuplex {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<bool>;
+ using DecodableType = chip::app::DataModel::Nullable<bool>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<bool> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FullDuplex::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FullDuplex
+namespace PacketRxCount {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PacketRxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PacketRxCount
+namespace PacketTxCount {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PacketTxCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PacketTxCount
+namespace TxErrCount {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TxErrCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TxErrCount
+namespace CollisionCount {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CollisionCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CollisionCount
+namespace OverrunCount {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OverrunCount
+namespace CarrierDetect {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<bool>;
+ using DecodableType = chip::app::DataModel::Nullable<bool>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<bool> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CarrierDetect::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CarrierDetect
+namespace TimeSinceReset {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimeSinceReset::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimeSinceReset
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PHYRate::TypeInfo::DecodableType PHYRate;
+ Attributes::FullDuplex::TypeInfo::DecodableType fullDuplex;
+ Attributes::PacketRxCount::TypeInfo::DecodableType packetRxCount = static_cast<uint64_t>(0);
+ Attributes::PacketTxCount::TypeInfo::DecodableType packetTxCount = static_cast<uint64_t>(0);
+ Attributes::TxErrCount::TypeInfo::DecodableType txErrCount = static_cast<uint64_t>(0);
+ Attributes::CollisionCount::TypeInfo::DecodableType collisionCount = static_cast<uint64_t>(0);
+ Attributes::OverrunCount::TypeInfo::DecodableType overrunCount = static_cast<uint64_t>(0);
+ Attributes::CarrierDetect::TypeInfo::DecodableType carrierDetect;
+ Attributes::TimeSinceReset::TypeInfo::DecodableType timeSinceReset = static_cast<uint64_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace EthernetNetworkDiagnostics
+namespace TimeSynchronization {
+namespace Structs {
+namespace DSTOffsetStruct {
+enum class Fields : uint8_t
+{
+ kOffset = 0,
+ kValidStarting = 1,
+ kValidUntil = 2,
+};
+
+struct Type
+{
+public:
+ int32_t offset = static_cast<int32_t>(0);
+ uint64_t validStarting = static_cast<uint64_t>(0);
+ DataModel::Nullable<uint64_t> validUntil;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace DSTOffsetStruct
+namespace FabricScopedTrustedTimeSourceStruct {
+enum class Fields : uint8_t
+{
+ kNodeID = 0,
+ kEndpoint = 1,
+};
+
+struct Type
+{
+public:
+ chip::NodeId nodeID = static_cast<chip::NodeId>(0);
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace FabricScopedTrustedTimeSourceStruct
+namespace TimeZoneStruct {
+enum class Fields : uint8_t
+{
+ kOffset = 0,
+ kValidAt = 1,
+ kName = 2,
+};
+
+struct Type
+{
+public:
+ int32_t offset = static_cast<int32_t>(0);
+ uint64_t validAt = static_cast<uint64_t>(0);
+ Optional<chip::CharSpan> name;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TimeZoneStruct
+namespace TrustedTimeSourceStruct {
+enum class Fields : uint8_t
+{
+ kFabricIndex = 0,
+ kNodeID = 1,
+ kEndpoint = 2,
+};
+
+struct Type
+{
+public:
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+ chip::NodeId nodeID = static_cast<chip::NodeId>(0);
+ chip::EndpointId endpoint = static_cast<chip::EndpointId>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TrustedTimeSourceStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SetUTCTime {
+struct Type;
+struct DecodableType;
+} // namespace SetUTCTime
+
+namespace SetTrustedTimeSource {
+struct Type;
+struct DecodableType;
+} // namespace SetTrustedTimeSource
+
+namespace SetTimeZone {
+struct Type;
+struct DecodableType;
+} // namespace SetTimeZone
+
+namespace SetTimeZoneResponse {
+struct Type;
+struct DecodableType;
+} // namespace SetTimeZoneResponse
+
+namespace SetDSTOffset {
+struct Type;
+struct DecodableType;
+} // namespace SetDSTOffset
+
+namespace SetDefaultNTP {
+struct Type;
+struct DecodableType;
+} // namespace SetDefaultNTP
+
+} // namespace Commands
+
+namespace Commands {
+namespace SetUTCTime {
+enum class Fields : uint8_t
+{
+ kUTCTime = 0,
+ kGranularity = 1,
+ kTimeSource = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetUTCTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ uint64_t UTCTime = static_cast<uint64_t>(0);
+ GranularityEnum granularity = static_cast<GranularityEnum>(0);
+ Optional<TimeSourceEnum> timeSource;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetUTCTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ uint64_t UTCTime = static_cast<uint64_t>(0);
+ GranularityEnum granularity = static_cast<GranularityEnum>(0);
+ Optional<TimeSourceEnum> timeSource;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetUTCTime
+namespace SetTrustedTimeSource {
+enum class Fields : uint8_t
+{
+ kTrustedTimeSource = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTrustedTimeSource::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::Nullable<Structs::FabricScopedTrustedTimeSourceStruct::Type> trustedTimeSource;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTrustedTimeSource::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::Nullable<Structs::FabricScopedTrustedTimeSourceStruct::DecodableType> trustedTimeSource;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTrustedTimeSource
+namespace SetTimeZone {
+enum class Fields : uint8_t
+{
+ kTimeZone = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTimeZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::List<const Structs::TimeZoneStruct::Type> timeZone;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::TimeSynchronization::Commands::SetTimeZoneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTimeZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::DecodableList<Structs::TimeZoneStruct::DecodableType> timeZone;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTimeZone
+namespace SetTimeZoneResponse {
+enum class Fields : uint8_t
+{
+ kDSTOffsetRequired = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTimeZoneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ bool DSTOffsetRequired = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTimeZoneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ bool DSTOffsetRequired = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTimeZoneResponse
+namespace SetDSTOffset {
+enum class Fields : uint8_t
+{
+ kDSTOffset = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetDSTOffset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::List<const Structs::DSTOffsetStruct::Type> DSTOffset;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetDSTOffset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::DecodableList<Structs::DSTOffsetStruct::DecodableType> DSTOffset;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetDSTOffset
+namespace SetDefaultNTP {
+enum class Fields : uint8_t
+{
+ kDefaultNTP = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetDefaultNTP::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::Nullable<chip::CharSpan> defaultNTP;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetDefaultNTP::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ DataModel::Nullable<chip::CharSpan> defaultNTP;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetDefaultNTP
+} // namespace Commands
+
+namespace Attributes {
+
+namespace UTCTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UTCTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UTCTime
+namespace Granularity {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TimeSynchronization::GranularityEnum;
+ using DecodableType = chip::app::Clusters::TimeSynchronization::GranularityEnum;
+ using DecodableArgType = chip::app::Clusters::TimeSynchronization::GranularityEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Granularity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Granularity
+namespace TimeSource {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TimeSynchronization::TimeSourceEnum;
+ using DecodableType = chip::app::Clusters::TimeSynchronization::TimeSourceEnum;
+ using DecodableArgType = chip::app::Clusters::TimeSynchronization::TimeSourceEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimeSource::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimeSource
+namespace TrustedTimeSource {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TrustedTimeSource::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TrustedTimeSource
+namespace DefaultNTP {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultNTP::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 128; }
+};
+} // namespace DefaultNTP
+namespace TimeZone {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimeZone::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimeZone
+namespace DSTOffset {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DSTOffset::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DSTOffset
+namespace LocalTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalTime
+namespace TimeZoneDatabase {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum;
+ using DecodableType = chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum;
+ using DecodableArgType = chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimeZoneDatabase::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimeZoneDatabase
+namespace NTPServerAvailable {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NTPServerAvailable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NTPServerAvailable
+namespace TimeZoneListMaxSize {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimeZoneListMaxSize::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimeZoneListMaxSize
+namespace DSTOffsetListMaxSize {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DSTOffsetListMaxSize::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DSTOffsetListMaxSize
+namespace SupportsDNSResolve {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportsDNSResolve::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportsDNSResolve
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::UTCTime::TypeInfo::DecodableType UTCTime;
+ Attributes::Granularity::TypeInfo::DecodableType granularity =
+ static_cast<chip::app::Clusters::TimeSynchronization::GranularityEnum>(0);
+ Attributes::TimeSource::TypeInfo::DecodableType timeSource =
+ static_cast<chip::app::Clusters::TimeSynchronization::TimeSourceEnum>(0);
+ Attributes::TrustedTimeSource::TypeInfo::DecodableType trustedTimeSource;
+ Attributes::DefaultNTP::TypeInfo::DecodableType defaultNTP;
+ Attributes::TimeZone::TypeInfo::DecodableType timeZone;
+ Attributes::DSTOffset::TypeInfo::DecodableType DSTOffset;
+ Attributes::LocalTime::TypeInfo::DecodableType localTime;
+ Attributes::TimeZoneDatabase::TypeInfo::DecodableType timeZoneDatabase =
+ static_cast<chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum>(0);
+ Attributes::NTPServerAvailable::TypeInfo::DecodableType NTPServerAvailable = static_cast<bool>(0);
+ Attributes::TimeZoneListMaxSize::TypeInfo::DecodableType timeZoneListMaxSize = static_cast<uint8_t>(0);
+ Attributes::DSTOffsetListMaxSize::TypeInfo::DecodableType DSTOffsetListMaxSize = static_cast<uint8_t>(0);
+ Attributes::SupportsDNSResolve::TypeInfo::DecodableType supportsDNSResolve = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace DSTTableEmpty {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DSTTableEmpty::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DSTTableEmpty::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace DSTTableEmpty
+namespace DSTStatus {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kDSTOffsetActive = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DSTStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ bool DSTOffsetActive = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DSTStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ bool DSTOffsetActive = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace DSTStatus
+namespace TimeZoneStatus {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kOffset = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TimeZoneStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ int32_t offset = static_cast<int32_t>(0);
+ Optional<chip::CharSpan> name;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TimeZoneStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ int32_t offset = static_cast<int32_t>(0);
+ Optional<chip::CharSpan> name;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TimeZoneStatus
+namespace TimeFailure {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TimeFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TimeFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TimeFailure
+namespace MissingTrustedTimeSource {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MissingTrustedTimeSource::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MissingTrustedTimeSource::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MissingTrustedTimeSource
+} // namespace Events
+} // namespace TimeSynchronization
+namespace BridgedDeviceBasicInformation {
+namespace Structs {
+namespace ProductAppearanceStruct {
+enum class Fields : uint8_t
+{
+ kFinish = 0,
+ kPrimaryColor = 1,
+};
+
+struct Type
+{
+public:
+ ProductFinishEnum finish = static_cast<ProductFinishEnum>(0);
+ DataModel::Nullable<ColorEnum> primaryColor;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ProductAppearanceStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace KeepActive {
+struct Type;
+struct DecodableType;
+} // namespace KeepActive
+
+} // namespace Commands
+
+namespace Commands {
+namespace KeepActive {
+enum class Fields : uint8_t
+{
+ kStayActiveDuration = 0,
+ kTimeoutMs = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeepActive::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ uint32_t stayActiveDuration = static_cast<uint32_t>(0);
+ uint32_t timeoutMs = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeepActive::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ uint32_t stayActiveDuration = static_cast<uint32_t>(0);
+ uint32_t timeoutMs = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeepActive
+} // namespace Commands
+
+namespace Attributes {
+
+namespace VendorName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace VendorName
+namespace VendorID {
+struct TypeInfo
+{
+ using Type = chip::VendorId;
+ using DecodableType = chip::VendorId;
+ using DecodableArgType = chip::VendorId;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace VendorID
+namespace ProductName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace ProductName
+namespace ProductID {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ProductID
+namespace NodeLabel {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NodeLabel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace NodeLabel
+namespace HardwareVersion {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HardwareVersion
+namespace HardwareVersionString {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersionString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace HardwareVersionString
+namespace SoftwareVersion {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SoftwareVersion
+namespace SoftwareVersionString {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersionString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace SoftwareVersionString
+namespace ManufacturingDate {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ManufacturingDate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace ManufacturingDate
+namespace PartNumber {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace PartNumber
+namespace ProductURL {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductURL::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 256; }
+};
+} // namespace ProductURL
+namespace ProductLabel {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductLabel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace ProductLabel
+namespace SerialNumber {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SerialNumber::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace SerialNumber
+namespace Reachable {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Reachable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Reachable
+namespace UniqueID {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UniqueID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace UniqueID
+namespace ProductAppearance {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::Type;
+ using DecodableType = chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::DecodableType;
+ using DecodableArgType =
+ const chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductAppearance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ProductAppearance
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::VendorName::TypeInfo::DecodableType vendorName;
+ Attributes::VendorID::TypeInfo::DecodableType vendorID = static_cast<chip::VendorId>(0);
+ Attributes::ProductName::TypeInfo::DecodableType productName;
+ Attributes::ProductID::TypeInfo::DecodableType productID = static_cast<uint16_t>(0);
+ Attributes::NodeLabel::TypeInfo::DecodableType nodeLabel;
+ Attributes::HardwareVersion::TypeInfo::DecodableType hardwareVersion = static_cast<uint16_t>(0);
+ Attributes::HardwareVersionString::TypeInfo::DecodableType hardwareVersionString;
+ Attributes::SoftwareVersion::TypeInfo::DecodableType softwareVersion = static_cast<uint32_t>(0);
+ Attributes::SoftwareVersionString::TypeInfo::DecodableType softwareVersionString;
+ Attributes::ManufacturingDate::TypeInfo::DecodableType manufacturingDate;
+ Attributes::PartNumber::TypeInfo::DecodableType partNumber;
+ Attributes::ProductURL::TypeInfo::DecodableType productURL;
+ Attributes::ProductLabel::TypeInfo::DecodableType productLabel;
+ Attributes::SerialNumber::TypeInfo::DecodableType serialNumber;
+ Attributes::Reachable::TypeInfo::DecodableType reachable = static_cast<bool>(0);
+ Attributes::UniqueID::TypeInfo::DecodableType uniqueID;
+ Attributes::ProductAppearance::TypeInfo::DecodableType productAppearance;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace StartUp {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kSoftwareVersion = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StartUp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StartUp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ uint32_t softwareVersion = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace StartUp
+namespace ShutDown {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ShutDown::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ShutDown::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ShutDown
+namespace Leave {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Leave::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Leave::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Leave
+namespace ReachableChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kReachableNewValue = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ bool reachableNewValue = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ bool reachableNewValue = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ReachableChanged
+namespace ActiveChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kPromisedActiveDuration = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ActiveChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t promisedActiveDuration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ActiveChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasicInformation::Id; }
+
+ uint32_t promisedActiveDuration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ActiveChanged
+} // namespace Events
+} // namespace BridgedDeviceBasicInformation
+namespace Switch {
+
+namespace Attributes {
+
+namespace NumberOfPositions {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPositions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfPositions
+namespace CurrentPosition {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPosition::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPosition
+namespace MultiPressMax {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MultiPressMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MultiPressMax
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::NumberOfPositions::TypeInfo::DecodableType numberOfPositions = static_cast<uint8_t>(0);
+ Attributes::CurrentPosition::TypeInfo::DecodableType currentPosition = static_cast<uint8_t>(0);
+ Attributes::MultiPressMax::TypeInfo::DecodableType multiPressMax = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace SwitchLatched {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kNewPosition = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SwitchLatched::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SwitchLatched::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SwitchLatched
+namespace InitialPress {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kNewPosition = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::InitialPress::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::InitialPress::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace InitialPress
+namespace LongPress {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kNewPosition = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LongPress::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LongPress::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LongPress
+namespace ShortRelease {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kPreviousPosition = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ShortRelease::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t previousPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ShortRelease::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t previousPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ShortRelease
+namespace LongRelease {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kPreviousPosition = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LongRelease::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t previousPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LongRelease::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t previousPosition = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LongRelease
+namespace MultiPressOngoing {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kNewPosition = 0,
+ kCurrentNumberOfPressesCounted = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MultiPressOngoing::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+ uint8_t currentNumberOfPressesCounted = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MultiPressOngoing::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t newPosition = static_cast<uint8_t>(0);
+ uint8_t currentNumberOfPressesCounted = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MultiPressOngoing
+namespace MultiPressComplete {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kPreviousPosition = 0,
+ kTotalNumberOfPressesCounted = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MultiPressComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t previousPosition = static_cast<uint8_t>(0);
+ uint8_t totalNumberOfPressesCounted = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MultiPressComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; }
+
+ uint8_t previousPosition = static_cast<uint8_t>(0);
+ uint8_t totalNumberOfPressesCounted = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MultiPressComplete
+} // namespace Events
+} // namespace Switch
+namespace AdministratorCommissioning {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace OpenCommissioningWindow {
+struct Type;
+struct DecodableType;
+} // namespace OpenCommissioningWindow
+
+namespace OpenBasicCommissioningWindow {
+struct Type;
+struct DecodableType;
+} // namespace OpenBasicCommissioningWindow
+
+namespace RevokeCommissioning {
+struct Type;
+struct DecodableType;
+} // namespace RevokeCommissioning
+
+} // namespace Commands
+
+namespace Commands {
+namespace OpenCommissioningWindow {
+enum class Fields : uint8_t
+{
+ kCommissioningTimeout = 0,
+ kPAKEPasscodeVerifier = 1,
+ kDiscriminator = 2,
+ kIterations = 3,
+ kSalt = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OpenCommissioningWindow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ uint16_t commissioningTimeout = static_cast<uint16_t>(0);
+ chip::ByteSpan PAKEPasscodeVerifier;
+ uint16_t discriminator = static_cast<uint16_t>(0);
+ uint32_t iterations = static_cast<uint32_t>(0);
+ chip::ByteSpan salt;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OpenCommissioningWindow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ uint16_t commissioningTimeout = static_cast<uint16_t>(0);
+ chip::ByteSpan PAKEPasscodeVerifier;
+ uint16_t discriminator = static_cast<uint16_t>(0);
+ uint32_t iterations = static_cast<uint32_t>(0);
+ chip::ByteSpan salt;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OpenCommissioningWindow
+namespace OpenBasicCommissioningWindow {
+enum class Fields : uint8_t
+{
+ kCommissioningTimeout = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OpenBasicCommissioningWindow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ uint16_t commissioningTimeout = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OpenBasicCommissioningWindow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ uint16_t commissioningTimeout = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OpenBasicCommissioningWindow
+namespace RevokeCommissioning {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RevokeCommissioning::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RevokeCommissioning::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RevokeCommissioning
+} // namespace Commands
+
+namespace Attributes {
+
+namespace WindowStatus {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum;
+ using DecodableType = chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum;
+ using DecodableArgType = chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WindowStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WindowStatus
+namespace AdminFabricIndex {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::FabricIndex>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::FabricIndex>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::FabricIndex> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AdminFabricIndex::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AdminFabricIndex
+namespace AdminVendorId {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::VendorId>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::VendorId>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::VendorId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AdminVendorId::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AdminVendorId
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::WindowStatus::TypeInfo::DecodableType windowStatus =
+ static_cast<chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum>(0);
+ Attributes::AdminFabricIndex::TypeInfo::DecodableType adminFabricIndex;
+ Attributes::AdminVendorId::TypeInfo::DecodableType adminVendorId;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace AdministratorCommissioning
+namespace OperationalCredentials {
+namespace Structs {
+namespace FabricDescriptorStruct {
+enum class Fields : uint8_t
+{
+ kRootPublicKey = 1,
+ kVendorID = 2,
+ kFabricID = 3,
+ kNodeID = 4,
+ kLabel = 5,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan rootPublicKey;
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ chip::FabricId fabricID = static_cast<chip::FabricId>(0);
+ chip::NodeId nodeID = static_cast<chip::NodeId>(0);
+ chip::CharSpan label;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace FabricDescriptorStruct
+namespace NOCStruct {
+enum class Fields : uint8_t
+{
+ kNoc = 1,
+ kIcac = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan noc;
+ DataModel::Nullable<chip::ByteSpan> icac;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace NOCStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace AttestationRequest {
+struct Type;
+struct DecodableType;
+} // namespace AttestationRequest
+
+namespace AttestationResponse {
+struct Type;
+struct DecodableType;
+} // namespace AttestationResponse
+
+namespace CertificateChainRequest {
+struct Type;
+struct DecodableType;
+} // namespace CertificateChainRequest
+
+namespace CertificateChainResponse {
+struct Type;
+struct DecodableType;
+} // namespace CertificateChainResponse
+
+namespace CSRRequest {
+struct Type;
+struct DecodableType;
+} // namespace CSRRequest
+
+namespace CSRResponse {
+struct Type;
+struct DecodableType;
+} // namespace CSRResponse
+
+namespace AddNOC {
+struct Type;
+struct DecodableType;
+} // namespace AddNOC
+
+namespace UpdateNOC {
+struct Type;
+struct DecodableType;
+} // namespace UpdateNOC
+
+namespace NOCResponse {
+struct Type;
+struct DecodableType;
+} // namespace NOCResponse
+
+namespace UpdateFabricLabel {
+struct Type;
+struct DecodableType;
+} // namespace UpdateFabricLabel
+
+namespace RemoveFabric {
+struct Type;
+struct DecodableType;
+} // namespace RemoveFabric
+
+namespace AddTrustedRootCertificate {
+struct Type;
+struct DecodableType;
+} // namespace AddTrustedRootCertificate
+
+} // namespace Commands
+
+namespace Commands {
+namespace AttestationRequest {
+enum class Fields : uint8_t
+{
+ kAttestationNonce = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AttestationRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan attestationNonce;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::AttestationResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AttestationRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan attestationNonce;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AttestationRequest
+namespace AttestationResponse {
+enum class Fields : uint8_t
+{
+ kAttestationElements = 0,
+ kAttestationSignature = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AttestationResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan attestationElements;
+ chip::ByteSpan attestationSignature;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AttestationResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan attestationElements;
+ chip::ByteSpan attestationSignature;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AttestationResponse
+namespace CertificateChainRequest {
+enum class Fields : uint8_t
+{
+ kCertificateType = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CertificateChainRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ CertificateChainTypeEnum certificateType = static_cast<CertificateChainTypeEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::CertificateChainResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CertificateChainRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ CertificateChainTypeEnum certificateType = static_cast<CertificateChainTypeEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CertificateChainRequest
+namespace CertificateChainResponse {
+enum class Fields : uint8_t
+{
+ kCertificate = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CertificateChainResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan certificate;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CertificateChainResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan certificate;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CertificateChainResponse
+namespace CSRRequest {
+enum class Fields : uint8_t
+{
+ kCSRNonce = 0,
+ kIsForUpdateNOC = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CSRRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan CSRNonce;
+ Optional<bool> isForUpdateNOC;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::CSRResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CSRRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan CSRNonce;
+ Optional<bool> isForUpdateNOC;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CSRRequest
+namespace CSRResponse {
+enum class Fields : uint8_t
+{
+ kNOCSRElements = 0,
+ kAttestationSignature = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CSRResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan NOCSRElements;
+ chip::ByteSpan attestationSignature;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CSRResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan NOCSRElements;
+ chip::ByteSpan attestationSignature;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CSRResponse
+namespace AddNOC {
+enum class Fields : uint8_t
+{
+ kNOCValue = 0,
+ kICACValue = 1,
+ kIPKValue = 2,
+ kCaseAdminSubject = 3,
+ kAdminVendorId = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddNOC::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan NOCValue;
+ Optional<chip::ByteSpan> ICACValue;
+ chip::ByteSpan IPKValue;
+ uint64_t caseAdminSubject = static_cast<uint64_t>(0);
+ chip::VendorId adminVendorId = static_cast<chip::VendorId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddNOC::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan NOCValue;
+ Optional<chip::ByteSpan> ICACValue;
+ chip::ByteSpan IPKValue;
+ uint64_t caseAdminSubject = static_cast<uint64_t>(0);
+ chip::VendorId adminVendorId = static_cast<chip::VendorId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddNOC
+namespace UpdateNOC {
+enum class Fields : uint8_t
+{
+ kNOCValue = 0,
+ kICACValue = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UpdateNOC::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan NOCValue;
+ Optional<chip::ByteSpan> ICACValue;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UpdateNOC::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan NOCValue;
+ Optional<chip::ByteSpan> ICACValue;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateNOC
+namespace NOCResponse {
+enum class Fields : uint8_t
+{
+ kStatusCode = 0,
+ kFabricIndex = 1,
+ kDebugText = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NOCResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ NodeOperationalCertStatusEnum statusCode = static_cast<NodeOperationalCertStatusEnum>(0);
+ Optional<chip::FabricIndex> fabricIndex;
+ Optional<chip::CharSpan> debugText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NOCResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ NodeOperationalCertStatusEnum statusCode = static_cast<NodeOperationalCertStatusEnum>(0);
+ Optional<chip::FabricIndex> fabricIndex;
+ Optional<chip::CharSpan> debugText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NOCResponse
+namespace UpdateFabricLabel {
+enum class Fields : uint8_t
+{
+ kLabel = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UpdateFabricLabel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::CharSpan label;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UpdateFabricLabel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::CharSpan label;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateFabricLabel
+namespace RemoveFabric {
+enum class Fields : uint8_t
+{
+ kFabricIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveFabric::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveFabric::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveFabric
+namespace AddTrustedRootCertificate {
+enum class Fields : uint8_t
+{
+ kRootCACertificate = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddTrustedRootCertificate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan rootCACertificate;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddTrustedRootCertificate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ chip::ByteSpan rootCACertificate;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddTrustedRootCertificate
+} // namespace Commands
+
+namespace Attributes {
+
+namespace NOCs {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NOCs::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NOCs
+namespace Fabrics {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Fabrics::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Fabrics
+namespace SupportedFabrics {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedFabrics::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedFabrics
+namespace CommissionedFabrics {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CommissionedFabrics::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CommissionedFabrics
+namespace TrustedRootCertificates {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TrustedRootCertificates::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TrustedRootCertificates
+namespace CurrentFabricIndex {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentFabricIndex::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentFabricIndex
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::NOCs::TypeInfo::DecodableType NOCs;
+ Attributes::Fabrics::TypeInfo::DecodableType fabrics;
+ Attributes::SupportedFabrics::TypeInfo::DecodableType supportedFabrics = static_cast<uint8_t>(0);
+ Attributes::CommissionedFabrics::TypeInfo::DecodableType commissionedFabrics = static_cast<uint8_t>(0);
+ Attributes::TrustedRootCertificates::TypeInfo::DecodableType trustedRootCertificates;
+ Attributes::CurrentFabricIndex::TypeInfo::DecodableType currentFabricIndex = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace OperationalCredentials
+namespace GroupKeyManagement {
+namespace Structs {
+namespace GroupInfoMapStruct {
+enum class Fields : uint8_t
+{
+ kGroupId = 1,
+ kEndpoints = 2,
+ kGroupName = 3,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::GroupId groupId = static_cast<chip::GroupId>(0);
+ DataModel::List<const chip::EndpointId> endpoints;
+ Optional<chip::CharSpan> groupName;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::GroupId groupId = static_cast<chip::GroupId>(0);
+ DataModel::DecodableList<chip::EndpointId> endpoints;
+ Optional<chip::CharSpan> groupName;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+};
+
+} // namespace GroupInfoMapStruct
+namespace GroupKeyMapStruct {
+enum class Fields : uint8_t
+{
+ kGroupId = 1,
+ kGroupKeySetID = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::GroupId groupId = static_cast<chip::GroupId>(0);
+ uint16_t groupKeySetID = static_cast<uint16_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace GroupKeyMapStruct
+namespace GroupKeySetStruct {
+enum class Fields : uint8_t
+{
+ kGroupKeySetID = 0,
+ kGroupKeySecurityPolicy = 1,
+ kEpochKey0 = 2,
+ kEpochStartTime0 = 3,
+ kEpochKey1 = 4,
+ kEpochStartTime1 = 5,
+ kEpochKey2 = 6,
+ kEpochStartTime2 = 7,
+};
+
+struct Type
+{
+public:
+ uint16_t groupKeySetID = static_cast<uint16_t>(0);
+ GroupKeySecurityPolicyEnum groupKeySecurityPolicy = static_cast<GroupKeySecurityPolicyEnum>(0);
+ DataModel::Nullable<chip::ByteSpan> epochKey0;
+ DataModel::Nullable<uint64_t> epochStartTime0;
+ DataModel::Nullable<chip::ByteSpan> epochKey1;
+ DataModel::Nullable<uint64_t> epochStartTime1;
+ DataModel::Nullable<chip::ByteSpan> epochKey2;
+ DataModel::Nullable<uint64_t> epochStartTime2;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace GroupKeySetStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace KeySetWrite {
+struct Type;
+struct DecodableType;
+} // namespace KeySetWrite
+
+namespace KeySetRead {
+struct Type;
+struct DecodableType;
+} // namespace KeySetRead
+
+namespace KeySetReadResponse {
+struct Type;
+struct DecodableType;
+} // namespace KeySetReadResponse
+
+namespace KeySetRemove {
+struct Type;
+struct DecodableType;
+} // namespace KeySetRemove
+
+namespace KeySetReadAllIndices {
+struct Type;
+struct DecodableType;
+} // namespace KeySetReadAllIndices
+
+namespace KeySetReadAllIndicesResponse {
+struct Type;
+struct DecodableType;
+} // namespace KeySetReadAllIndicesResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace KeySetWrite {
+enum class Fields : uint8_t
+{
+ kGroupKeySet = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeySetWrite::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ Structs::GroupKeySetStruct::Type groupKeySet;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeySetWrite::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ Structs::GroupKeySetStruct::DecodableType groupKeySet;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeySetWrite
+namespace KeySetRead {
+enum class Fields : uint8_t
+{
+ kGroupKeySetID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeySetRead::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ uint16_t groupKeySetID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GroupKeyManagement::Commands::KeySetReadResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeySetRead::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ uint16_t groupKeySetID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeySetRead
+namespace KeySetReadResponse {
+enum class Fields : uint8_t
+{
+ kGroupKeySet = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeySetReadResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ Structs::GroupKeySetStruct::Type groupKeySet;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeySetReadResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ Structs::GroupKeySetStruct::DecodableType groupKeySet;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeySetReadResponse
+namespace KeySetRemove {
+enum class Fields : uint8_t
+{
+ kGroupKeySetID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeySetRemove::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ uint16_t groupKeySetID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeySetRemove::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ uint16_t groupKeySetID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeySetRemove
+namespace KeySetReadAllIndices {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndices::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::GroupKeyManagement::Commands::KeySetReadAllIndicesResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndices::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeySetReadAllIndices
+namespace KeySetReadAllIndicesResponse {
+enum class Fields : uint8_t
+{
+ kGroupKeySetIDs = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndicesResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ DataModel::List<const uint16_t> groupKeySetIDs;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndicesResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ DataModel::DecodableList<uint16_t> groupKeySetIDs;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace KeySetReadAllIndicesResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GroupKeyMap {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::GroupKeyMap::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GroupKeyMap
+namespace GroupTable {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::GroupTable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GroupTable
+namespace MaxGroupsPerFabric {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxGroupsPerFabric::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxGroupsPerFabric
+namespace MaxGroupKeysPerFabric {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxGroupKeysPerFabric::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxGroupKeysPerFabric
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GroupKeyMap::TypeInfo::DecodableType groupKeyMap;
+ Attributes::GroupTable::TypeInfo::DecodableType groupTable;
+ Attributes::MaxGroupsPerFabric::TypeInfo::DecodableType maxGroupsPerFabric = static_cast<uint16_t>(0);
+ Attributes::MaxGroupKeysPerFabric::TypeInfo::DecodableType maxGroupKeysPerFabric = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace GroupKeyManagement
+namespace FixedLabel {
+namespace Structs {
+namespace LabelStruct = Clusters::detail::Structs::LabelStruct;
+} // namespace Structs
+
+namespace Attributes {
+
+namespace LabelList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::FixedLabel::Structs::LabelStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LabelList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LabelList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::LabelList::TypeInfo::DecodableType labelList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace FixedLabel
+namespace UserLabel {
+namespace Structs {
+namespace LabelStruct = Clusters::detail::Structs::LabelStruct;
+} // namespace Structs
+
+namespace Attributes {
+
+namespace LabelList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LabelList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LabelList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::LabelList::TypeInfo::DecodableType labelList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace UserLabel
+namespace ProxyConfiguration {
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ProxyConfiguration
+namespace ProxyDiscovery {
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ProxyDiscovery
+namespace ProxyValid {
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ProxyValid
+namespace BooleanState {
+
+namespace Attributes {
+
+namespace StateValue {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StateValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StateValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::StateValue::TypeInfo::DecodableType stateValue = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace StateChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kStateValue = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ bool stateValue = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; }
+
+ bool stateValue = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace StateChange
+} // namespace Events
+} // namespace BooleanState
+namespace IcdManagement {
+namespace Structs {
+namespace MonitoringRegistrationStruct {
+enum class Fields : uint8_t
+{
+ kCheckInNodeID = 1,
+ kMonitoredSubject = 2,
+ kClientType = 4,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::NodeId checkInNodeID = static_cast<chip::NodeId>(0);
+ uint64_t monitoredSubject = static_cast<uint64_t>(0);
+ ClientTypeEnum clientType = static_cast<ClientTypeEnum>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MonitoringRegistrationStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace RegisterClient {
+struct Type;
+struct DecodableType;
+} // namespace RegisterClient
+
+namespace RegisterClientResponse {
+struct Type;
+struct DecodableType;
+} // namespace RegisterClientResponse
+
+namespace UnregisterClient {
+struct Type;
+struct DecodableType;
+} // namespace UnregisterClient
+
+namespace StayActiveRequest {
+struct Type;
+struct DecodableType;
+} // namespace StayActiveRequest
+
+namespace StayActiveResponse {
+struct Type;
+struct DecodableType;
+} // namespace StayActiveResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace RegisterClient {
+enum class Fields : uint8_t
+{
+ kCheckInNodeID = 0,
+ kMonitoredSubject = 1,
+ kKey = 2,
+ kVerificationKey = 3,
+ kClientType = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RegisterClient::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ chip::NodeId checkInNodeID = static_cast<chip::NodeId>(0);
+ uint64_t monitoredSubject = static_cast<uint64_t>(0);
+ chip::ByteSpan key;
+ Optional<chip::ByteSpan> verificationKey;
+ ClientTypeEnum clientType = static_cast<ClientTypeEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::IcdManagement::Commands::RegisterClientResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RegisterClient::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ chip::NodeId checkInNodeID = static_cast<chip::NodeId>(0);
+ uint64_t monitoredSubject = static_cast<uint64_t>(0);
+ chip::ByteSpan key;
+ Optional<chip::ByteSpan> verificationKey;
+ ClientTypeEnum clientType = static_cast<ClientTypeEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RegisterClient
+namespace RegisterClientResponse {
+enum class Fields : uint8_t
+{
+ kICDCounter = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RegisterClientResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ uint32_t ICDCounter = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RegisterClientResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ uint32_t ICDCounter = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RegisterClientResponse
+namespace UnregisterClient {
+enum class Fields : uint8_t
+{
+ kCheckInNodeID = 0,
+ kVerificationKey = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UnregisterClient::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ chip::NodeId checkInNodeID = static_cast<chip::NodeId>(0);
+ Optional<chip::ByteSpan> verificationKey;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UnregisterClient::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ chip::NodeId checkInNodeID = static_cast<chip::NodeId>(0);
+ Optional<chip::ByteSpan> verificationKey;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnregisterClient
+namespace StayActiveRequest {
+enum class Fields : uint8_t
+{
+ kStayActiveDuration = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StayActiveRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ uint32_t stayActiveDuration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::IcdManagement::Commands::StayActiveResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StayActiveRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ uint32_t stayActiveDuration = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StayActiveRequest
+namespace StayActiveResponse {
+enum class Fields : uint8_t
+{
+ kPromisedActiveDuration = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StayActiveResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ uint32_t promisedActiveDuration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StayActiveResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ uint32_t promisedActiveDuration = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StayActiveResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace IdleModeDuration {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::IdleModeDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace IdleModeDuration
+namespace ActiveModeDuration {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveModeDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveModeDuration
+namespace ActiveModeThreshold {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveModeThreshold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveModeThreshold
+namespace RegisteredClients {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RegisteredClients::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RegisteredClients
+namespace ICDCounter {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ICDCounter::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ICDCounter
+namespace ClientsSupportedPerFabric {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ClientsSupportedPerFabric::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ClientsSupportedPerFabric
+namespace UserActiveModeTriggerHint {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UserActiveModeTriggerHint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UserActiveModeTriggerHint
+namespace UserActiveModeTriggerInstruction {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UserActiveModeTriggerInstruction::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 128; }
+};
+} // namespace UserActiveModeTriggerInstruction
+namespace OperatingMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::IcdManagement::OperatingModeEnum;
+ using DecodableType = chip::app::Clusters::IcdManagement::OperatingModeEnum;
+ using DecodableArgType = chip::app::Clusters::IcdManagement::OperatingModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperatingMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperatingMode
+namespace MaximumCheckInBackOff {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaximumCheckInBackOff::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaximumCheckInBackOff
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::IcdManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::IdleModeDuration::TypeInfo::DecodableType idleModeDuration = static_cast<uint32_t>(0);
+ Attributes::ActiveModeDuration::TypeInfo::DecodableType activeModeDuration = static_cast<uint32_t>(0);
+ Attributes::ActiveModeThreshold::TypeInfo::DecodableType activeModeThreshold = static_cast<uint16_t>(0);
+ Attributes::RegisteredClients::TypeInfo::DecodableType registeredClients;
+ Attributes::ICDCounter::TypeInfo::DecodableType ICDCounter = static_cast<uint32_t>(0);
+ Attributes::ClientsSupportedPerFabric::TypeInfo::DecodableType clientsSupportedPerFabric = static_cast<uint16_t>(0);
+ Attributes::UserActiveModeTriggerHint::TypeInfo::DecodableType userActiveModeTriggerHint =
+ static_cast<chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>>(0);
+ Attributes::UserActiveModeTriggerInstruction::TypeInfo::DecodableType userActiveModeTriggerInstruction;
+ Attributes::OperatingMode::TypeInfo::DecodableType operatingMode =
+ static_cast<chip::app::Clusters::IcdManagement::OperatingModeEnum>(0);
+ Attributes::MaximumCheckInBackOff::TypeInfo::DecodableType maximumCheckInBackOff = static_cast<uint32_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace IcdManagement
+namespace Timer {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SetTimer {
+struct Type;
+struct DecodableType;
+} // namespace SetTimer
+
+namespace ResetTimer {
+struct Type;
+struct DecodableType;
+} // namespace ResetTimer
+
+namespace AddTime {
+struct Type;
+struct DecodableType;
+} // namespace AddTime
+
+namespace ReduceTime {
+struct Type;
+struct DecodableType;
+} // namespace ReduceTime
+
+} // namespace Commands
+
+namespace Commands {
+namespace SetTimer {
+enum class Fields : uint8_t
+{
+ kNewTime = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTimer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ uint32_t newTime = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTimer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ uint32_t newTime = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTimer
+namespace ResetTimer {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetTimer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetTimer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetTimer
+namespace AddTime {
+enum class Fields : uint8_t
+{
+ kAdditionalTime = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ uint32_t additionalTime = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ uint32_t additionalTime = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddTime
+namespace ReduceTime {
+enum class Fields : uint8_t
+{
+ kTimeReduction = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ReduceTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ uint32_t timeReduction = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ReduceTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ uint32_t timeReduction = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ReduceTime
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SetTime {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SetTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SetTime
+namespace TimeRemaining {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimeRemaining::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimeRemaining
+namespace TimerState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Timer::TimerStatusEnum;
+ using DecodableType = chip::app::Clusters::Timer::TimerStatusEnum;
+ using DecodableArgType = chip::app::Clusters::Timer::TimerStatusEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimerState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TimerState
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Timer::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SetTime::TypeInfo::DecodableType setTime = static_cast<uint32_t>(0);
+ Attributes::TimeRemaining::TypeInfo::DecodableType timeRemaining = static_cast<uint32_t>(0);
+ Attributes::TimerState::TypeInfo::DecodableType timerState = static_cast<chip::app::Clusters::Timer::TimerStatusEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Timer
+namespace OvenCavityOperationalState {
+namespace Structs {
+namespace ErrorStateStruct = Clusters::detail::Structs::ErrorStateStruct;
+namespace OperationalStateStruct = Clusters::detail::Structs::OperationalStateStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Pause {
+struct Type;
+struct DecodableType;
+} // namespace Pause
+
+namespace Stop {
+struct Type;
+struct DecodableType;
+} // namespace Stop
+
+namespace Start {
+struct Type;
+struct DecodableType;
+} // namespace Start
+
+namespace Resume {
+struct Type;
+struct DecodableType;
+} // namespace Resume
+
+namespace OperationalCommandResponse {
+struct Type;
+struct DecodableType;
+} // namespace OperationalCommandResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace Pause {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OvenCavityOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Pause
+namespace Stop {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OvenCavityOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Stop
+namespace Start {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Start::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OvenCavityOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Start::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Start
+namespace Resume {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Resume::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OvenCavityOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Resume::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Resume
+namespace OperationalCommandResponse {
+enum class Fields : uint8_t
+{
+ kCommandResponseState = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OperationalCommandResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ Structs::ErrorStateStruct::Type commandResponseState;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OperationalCommandResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ Structs::ErrorStateStruct::DecodableType commandResponseState;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OperationalCommandResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace PhaseList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::CharSpan>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<chip::CharSpan>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<chip::CharSpan>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhaseList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhaseList
+namespace CurrentPhase {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPhase::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPhase
+namespace CountdownTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CountdownTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CountdownTime
+namespace OperationalStateList {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::OvenCavityOperationalState::Structs::OperationalStateStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OvenCavityOperationalState::Structs::OperationalStateStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OvenCavityOperationalState::Structs::OperationalStateStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalStateList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalStateList
+namespace OperationalState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OvenCavityOperationalState::OperationalStateEnum;
+ using DecodableType = chip::app::Clusters::OvenCavityOperationalState::OperationalStateEnum;
+ using DecodableArgType = chip::app::Clusters::OvenCavityOperationalState::OperationalStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalState
+namespace OperationalError {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OvenCavityOperationalState::Structs::ErrorStateStruct::Type;
+ using DecodableType = chip::app::Clusters::OvenCavityOperationalState::Structs::ErrorStateStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::OvenCavityOperationalState::Structs::ErrorStateStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalError::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalError
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PhaseList::TypeInfo::DecodableType phaseList;
+ Attributes::CurrentPhase::TypeInfo::DecodableType currentPhase;
+ Attributes::CountdownTime::TypeInfo::DecodableType countdownTime;
+ Attributes::OperationalStateList::TypeInfo::DecodableType operationalStateList;
+ Attributes::OperationalState::TypeInfo::DecodableType operationalState =
+ static_cast<chip::app::Clusters::OvenCavityOperationalState::OperationalStateEnum>(0);
+ Attributes::OperationalError::TypeInfo::DecodableType operationalError;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace OperationalError {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kErrorState = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationalError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Structs::ErrorStateStruct::Type errorState;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationalError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ Structs::ErrorStateStruct::DecodableType errorState;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OperationalError
+namespace OperationCompletion {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCompletionErrorCode = 0,
+ kTotalOperationalTime = 1,
+ kPausedTime = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationCompletion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t completionErrorCode = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> pausedTime;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationCompletion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenCavityOperationalState::Id; }
+
+ uint8_t completionErrorCode = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> pausedTime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OperationCompletion
+} // namespace Events
+} // namespace OvenCavityOperationalState
+namespace OvenMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OvenMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::OvenMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::OvenMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::OvenMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace StartUpMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpMode
+namespace OnMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OvenMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::StartUpMode::TypeInfo::DecodableType startUpMode;
+ Attributes::OnMode::TypeInfo::DecodableType onMode;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace OvenMode
+namespace LaundryDryerControls {
+
+namespace Attributes {
+
+namespace SupportedDrynessLevels {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedDrynessLevels::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedDrynessLevels
+namespace SelectedDrynessLevel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SelectedDrynessLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SelectedDrynessLevel
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryDryerControls::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedDrynessLevels::TypeInfo::DecodableType supportedDrynessLevels;
+ Attributes::SelectedDrynessLevel::TypeInfo::DecodableType selectedDrynessLevel;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace LaundryDryerControls
+namespace ModeSelect {
+namespace Structs {
+namespace SemanticTagStruct {
+enum class Fields : uint8_t
+{
+ kMfgCode = 0,
+ kValue = 1,
+};
+
+struct Type
+{
+public:
+ chip::VendorId mfgCode = static_cast<chip::VendorId>(0);
+ uint16_t value = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SemanticTagStruct
+namespace ModeOptionStruct {
+enum class Fields : uint8_t
+{
+ kLabel = 0,
+ kMode = 1,
+ kSemanticTags = 2,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan label;
+ uint8_t mode = static_cast<uint8_t>(0);
+ DataModel::List<const Structs::SemanticTagStruct::Type> semanticTags;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::CharSpan label;
+ uint8_t mode = static_cast<uint8_t>(0);
+ DataModel::DecodableList<Structs::SemanticTagStruct::DecodableType> semanticTags;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ModeOptionStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Description {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 64; }
+};
+} // namespace Description
+namespace StandardNamespace {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StandardNamespace::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StandardNamespace
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace StartUpMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpMode
+namespace OnMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Description::TypeInfo::DecodableType description;
+ Attributes::StandardNamespace::TypeInfo::DecodableType standardNamespace;
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::StartUpMode::TypeInfo::DecodableType startUpMode;
+ Attributes::OnMode::TypeInfo::DecodableType onMode;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ModeSelect
+namespace LaundryWasherMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::LaundryWasherMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::LaundryWasherMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::LaundryWasherMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::LaundryWasherMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace StartUpMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpMode
+namespace OnMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::StartUpMode::TypeInfo::DecodableType startUpMode;
+ Attributes::OnMode::TypeInfo::DecodableType onMode;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace LaundryWasherMode
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<
+ const chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace StartUpMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpMode
+namespace OnMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::StartUpMode::TypeInfo::DecodableType startUpMode;
+ Attributes::OnMode::TypeInfo::DecodableType onMode;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+namespace LaundryWasherControls {
+
+namespace Attributes {
+
+namespace SpinSpeeds {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpinSpeeds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpinSpeeds
+namespace SpinSpeedCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpinSpeedCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpinSpeedCurrent
+namespace NumberOfRinses {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum;
+ using DecodableType = chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum;
+ using DecodableArgType = chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfRinses::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfRinses
+namespace SupportedRinses {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedRinses::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedRinses
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::LaundryWasherControls::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SpinSpeeds::TypeInfo::DecodableType spinSpeeds;
+ Attributes::SpinSpeedCurrent::TypeInfo::DecodableType spinSpeedCurrent;
+ Attributes::NumberOfRinses::TypeInfo::DecodableType numberOfRinses =
+ static_cast<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>(0);
+ Attributes::SupportedRinses::TypeInfo::DecodableType supportedRinses;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace LaundryWasherControls
+namespace RvcRunMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::RvcRunMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::RvcRunMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::RvcRunMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::RvcRunMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcRunMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace RvcRunMode
+namespace RvcCleanMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::RvcCleanMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::RvcCleanMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::RvcCleanMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::RvcCleanMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcCleanMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace RvcCleanMode
+namespace TemperatureControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SetTemperature {
+struct Type;
+struct DecodableType;
+} // namespace SetTemperature
+
+} // namespace Commands
+
+namespace Commands {
+namespace SetTemperature {
+enum class Fields : uint8_t
+{
+ kTargetTemperature = 0,
+ kTargetTemperatureLevel = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+
+ Optional<int16_t> targetTemperature;
+ Optional<uint8_t> targetTemperatureLevel;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+
+ Optional<int16_t> targetTemperature;
+ Optional<uint8_t> targetTemperatureLevel;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTemperature
+} // namespace Commands
+
+namespace Attributes {
+
+namespace TemperatureSetpoint {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureSetpoint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TemperatureSetpoint
+namespace MinTemperature {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinTemperature::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinTemperature
+namespace MaxTemperature {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxTemperature::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxTemperature
+namespace Step {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Step::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Step
+namespace SelectedTemperatureLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SelectedTemperatureLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SelectedTemperatureLevel
+namespace SupportedTemperatureLevels {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedTemperatureLevels::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedTemperatureLevels
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::TemperatureSetpoint::TypeInfo::DecodableType temperatureSetpoint = static_cast<int16_t>(0);
+ Attributes::MinTemperature::TypeInfo::DecodableType minTemperature = static_cast<int16_t>(0);
+ Attributes::MaxTemperature::TypeInfo::DecodableType maxTemperature = static_cast<int16_t>(0);
+ Attributes::Step::TypeInfo::DecodableType step = static_cast<int16_t>(0);
+ Attributes::SelectedTemperatureLevel::TypeInfo::DecodableType selectedTemperatureLevel = static_cast<uint8_t>(0);
+ Attributes::SupportedTemperatureLevels::TypeInfo::DecodableType supportedTemperatureLevels;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+
+namespace Attributes {
+
+namespace Mask {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Mask::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Mask
+namespace State {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace State
+namespace Supported {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Supported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Supported
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Mask::TypeInfo::DecodableType mask =
+ static_cast<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>(0);
+ Attributes::State::TypeInfo::DecodableType state =
+ static_cast<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>(0);
+ Attributes::Supported::TypeInfo::DecodableType supported =
+ static_cast<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace Notify {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kActive = 0,
+ kInactive = 1,
+ kState = 2,
+ kMask = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Notify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<AlarmBitmap> active = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> inactive = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> state = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> mask = static_cast<chip::BitMask<AlarmBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Notify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+
+ chip::BitMask<AlarmBitmap> active = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> inactive = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> state = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> mask = static_cast<chip::BitMask<AlarmBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Notify
+} // namespace Events
+} // namespace RefrigeratorAlarm
+namespace DishwasherMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DishwasherMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::DishwasherMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::DishwasherMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::DishwasherMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace StartUpMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpMode
+namespace OnMode {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::StartUpMode::TypeInfo::DecodableType startUpMode;
+ Attributes::OnMode::TypeInfo::DecodableType onMode;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace DishwasherMode
+namespace AirQuality {
+
+namespace Attributes {
+
+namespace AirQuality {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::AirQuality::AirQualityEnum;
+ using DecodableType = chip::app::Clusters::AirQuality::AirQualityEnum;
+ using DecodableArgType = chip::app::Clusters::AirQuality::AirQualityEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AirQuality::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AirQuality
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::AirQuality::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::AirQuality::TypeInfo::DecodableType airQuality =
+ static_cast<chip::app::Clusters::AirQuality::AirQualityEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace AirQuality
+namespace SmokeCoAlarm {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SelfTestRequest {
+struct Type;
+struct DecodableType;
+} // namespace SelfTestRequest
+
+} // namespace Commands
+
+namespace Commands {
+namespace SelfTestRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SelfTestRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SelfTestRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelfTestRequest
+} // namespace Commands
+
+namespace Attributes {
+
+namespace ExpressedState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ExpressedState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ExpressedState
+namespace SmokeState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SmokeState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SmokeState
+namespace COState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::COState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace COState
+namespace BatteryAlert {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatteryAlert::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatteryAlert
+namespace DeviceMuted {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DeviceMuted::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DeviceMuted
+namespace TestInProgress {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TestInProgress::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TestInProgress
+namespace HardwareFaultAlert {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HardwareFaultAlert::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HardwareFaultAlert
+namespace EndOfServiceAlert {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EndOfServiceAlert::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EndOfServiceAlert
+namespace InterconnectSmokeAlarm {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InterconnectSmokeAlarm::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InterconnectSmokeAlarm
+namespace InterconnectCOAlarm {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InterconnectCOAlarm::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InterconnectCOAlarm
+namespace ContaminationState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ContaminationState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ContaminationState
+namespace SmokeSensitivityLevel {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
+ using DecodableType = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
+ using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SmokeSensitivityLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SmokeSensitivityLevel
+namespace ExpiryDate {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ExpiryDate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ExpiryDate
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::ExpressedState::TypeInfo::DecodableType expressedState =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>(0);
+ Attributes::SmokeState::TypeInfo::DecodableType smokeState =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
+ Attributes::COState::TypeInfo::DecodableType COState = static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
+ Attributes::BatteryAlert::TypeInfo::DecodableType batteryAlert =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
+ Attributes::DeviceMuted::TypeInfo::DecodableType deviceMuted =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>(0);
+ Attributes::TestInProgress::TypeInfo::DecodableType testInProgress = static_cast<bool>(0);
+ Attributes::HardwareFaultAlert::TypeInfo::DecodableType hardwareFaultAlert = static_cast<bool>(0);
+ Attributes::EndOfServiceAlert::TypeInfo::DecodableType endOfServiceAlert =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>(0);
+ Attributes::InterconnectSmokeAlarm::TypeInfo::DecodableType interconnectSmokeAlarm =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
+ Attributes::InterconnectCOAlarm::TypeInfo::DecodableType interconnectCOAlarm =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
+ Attributes::ContaminationState::TypeInfo::DecodableType contaminationState =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>(0);
+ Attributes::SmokeSensitivityLevel::TypeInfo::DecodableType smokeSensitivityLevel =
+ static_cast<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>(0);
+ Attributes::ExpiryDate::TypeInfo::DecodableType expiryDate = static_cast<uint32_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace SmokeAlarm {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kAlarmSeverityLevel = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SmokeAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SmokeAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SmokeAlarm
+namespace COAlarm {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kAlarmSeverityLevel = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::COAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::COAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace COAlarm
+namespace LowBattery {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kAlarmSeverityLevel = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LowBattery::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LowBattery::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LowBattery
+namespace HardwareFault {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::HardwareFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::HardwareFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace HardwareFault
+namespace EndOfService {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EndOfService::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EndOfService::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace EndOfService
+namespace SelfTestComplete {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SelfTestComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SelfTestComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SelfTestComplete
+namespace AlarmMuted {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AlarmMuted::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AlarmMuted::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AlarmMuted
+namespace MuteEnded {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MuteEnded::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MuteEnded::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MuteEnded
+namespace InterconnectSmokeAlarm {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kAlarmSeverityLevel = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::InterconnectSmokeAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::InterconnectSmokeAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace InterconnectSmokeAlarm
+namespace InterconnectCOAlarm {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kAlarmSeverityLevel = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::InterconnectCOAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::InterconnectCOAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ AlarmStateEnum alarmSeverityLevel = static_cast<AlarmStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace InterconnectCOAlarm
+namespace AllClear {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AllClear::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AllClear::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AllClear
+} // namespace Events
+} // namespace SmokeCoAlarm
+namespace DishwasherAlarm {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Reset {
+struct Type;
+struct DecodableType;
+} // namespace Reset
+
+namespace ModifyEnabledAlarms {
+struct Type;
+struct DecodableType;
+} // namespace ModifyEnabledAlarms
+
+} // namespace Commands
+
+namespace Commands {
+namespace Reset {
+enum class Fields : uint8_t
+{
+ kAlarms = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Reset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+
+ chip::BitMask<AlarmBitmap> alarms = static_cast<chip::BitMask<AlarmBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Reset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+
+ chip::BitMask<AlarmBitmap> alarms = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Reset
+namespace ModifyEnabledAlarms {
+enum class Fields : uint8_t
+{
+ kMask = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ModifyEnabledAlarms::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+
+ chip::BitMask<AlarmBitmap> mask = static_cast<chip::BitMask<AlarmBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ModifyEnabledAlarms::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+
+ chip::BitMask<AlarmBitmap> mask = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ModifyEnabledAlarms
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Mask {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Mask::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Mask
+namespace Latch {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Latch::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Latch
+namespace State {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace State
+namespace Supported {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Supported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Supported
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Mask::TypeInfo::DecodableType mask =
+ static_cast<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>(0);
+ Attributes::Latch::TypeInfo::DecodableType latch =
+ static_cast<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>(0);
+ Attributes::State::TypeInfo::DecodableType state =
+ static_cast<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>(0);
+ Attributes::Supported::TypeInfo::DecodableType supported =
+ static_cast<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace Notify {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kActive = 0,
+ kInactive = 1,
+ kState = 2,
+ kMask = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Notify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<AlarmBitmap> active = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> inactive = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> state = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> mask = static_cast<chip::BitMask<AlarmBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Notify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; }
+
+ chip::BitMask<AlarmBitmap> active = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> inactive = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> state = static_cast<chip::BitMask<AlarmBitmap>>(0);
+ chip::BitMask<AlarmBitmap> mask = static_cast<chip::BitMask<AlarmBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Notify
+} // namespace Events
+} // namespace DishwasherAlarm
+namespace MicrowaveOvenMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::MicrowaveOvenMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::MicrowaveOvenMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::MicrowaveOvenMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace MicrowaveOvenMode
+namespace MicrowaveOvenControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SetCookingParameters {
+struct Type;
+struct DecodableType;
+} // namespace SetCookingParameters
+
+namespace AddMoreTime {
+struct Type;
+struct DecodableType;
+} // namespace AddMoreTime
+
+} // namespace Commands
+
+namespace Commands {
+namespace SetCookingParameters {
+enum class Fields : uint8_t
+{
+ kCookMode = 0,
+ kCookTime = 1,
+ kPowerSetting = 2,
+ kWattSettingIndex = 3,
+ kStartAfterSetting = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetCookingParameters::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+
+ Optional<uint8_t> cookMode;
+ Optional<uint32_t> cookTime;
+ Optional<uint8_t> powerSetting;
+ Optional<uint8_t> wattSettingIndex;
+ Optional<bool> startAfterSetting;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetCookingParameters::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+
+ Optional<uint8_t> cookMode;
+ Optional<uint32_t> cookTime;
+ Optional<uint8_t> powerSetting;
+ Optional<uint8_t> wattSettingIndex;
+ Optional<bool> startAfterSetting;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetCookingParameters
+namespace AddMoreTime {
+enum class Fields : uint8_t
+{
+ kTimeToAdd = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddMoreTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+
+ uint32_t timeToAdd = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddMoreTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+
+ uint32_t timeToAdd = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddMoreTime
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CookTime {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CookTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CookTime
+namespace MaxCookTime {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxCookTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxCookTime
+namespace PowerSetting {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PowerSetting::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PowerSetting
+namespace MinPower {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinPower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinPower
+namespace MaxPower {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxPower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxPower
+namespace PowerStep {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PowerStep::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PowerStep
+namespace SupportedWatts {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const uint16_t>;
+ using DecodableType = chip::app::DataModel::DecodableList<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedWatts::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedWatts
+namespace SelectedWattIndex {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SelectedWattIndex::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SelectedWattIndex
+namespace WattRating {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WattRating::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WattRating
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::MicrowaveOvenControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CookTime::TypeInfo::DecodableType cookTime = static_cast<uint32_t>(0);
+ Attributes::MaxCookTime::TypeInfo::DecodableType maxCookTime = static_cast<uint32_t>(0);
+ Attributes::PowerSetting::TypeInfo::DecodableType powerSetting = static_cast<uint8_t>(0);
+ Attributes::MinPower::TypeInfo::DecodableType minPower = static_cast<uint8_t>(0);
+ Attributes::MaxPower::TypeInfo::DecodableType maxPower = static_cast<uint8_t>(0);
+ Attributes::PowerStep::TypeInfo::DecodableType powerStep = static_cast<uint8_t>(0);
+ Attributes::SupportedWatts::TypeInfo::DecodableType supportedWatts;
+ Attributes::SelectedWattIndex::TypeInfo::DecodableType selectedWattIndex = static_cast<uint8_t>(0);
+ Attributes::WattRating::TypeInfo::DecodableType wattRating = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace MicrowaveOvenControl
+namespace OperationalState {
+namespace Structs {
+namespace ErrorStateStruct = Clusters::detail::Structs::ErrorStateStruct;
+namespace OperationalStateStruct = Clusters::detail::Structs::OperationalStateStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Pause {
+struct Type;
+struct DecodableType;
+} // namespace Pause
+
+namespace Stop {
+struct Type;
+struct DecodableType;
+} // namespace Stop
+
+namespace Start {
+struct Type;
+struct DecodableType;
+} // namespace Start
+
+namespace Resume {
+struct Type;
+struct DecodableType;
+} // namespace Resume
+
+namespace OperationalCommandResponse {
+struct Type;
+struct DecodableType;
+} // namespace OperationalCommandResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace Pause {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Pause
+namespace Stop {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Stop
+namespace Start {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Start::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Start::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Start
+namespace Resume {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Resume::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::OperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Resume::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Resume
+namespace OperationalCommandResponse {
+enum class Fields : uint8_t
+{
+ kCommandResponseState = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OperationalCommandResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ Structs::ErrorStateStruct::Type commandResponseState;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OperationalCommandResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ Structs::ErrorStateStruct::DecodableType commandResponseState;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OperationalCommandResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace PhaseList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::CharSpan>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<chip::CharSpan>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<chip::CharSpan>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhaseList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhaseList
+namespace CurrentPhase {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPhase::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPhase
+namespace CountdownTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CountdownTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CountdownTime
+namespace OperationalStateList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::OperationalState::Structs::OperationalStateStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalState::Structs::OperationalStateStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::OperationalState::Structs::OperationalStateStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalStateList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalStateList
+namespace OperationalState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OperationalState::OperationalStateEnum;
+ using DecodableType = chip::app::Clusters::OperationalState::OperationalStateEnum;
+ using DecodableArgType = chip::app::Clusters::OperationalState::OperationalStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalState
+namespace OperationalError {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OperationalState::Structs::ErrorStateStruct::Type;
+ using DecodableType = chip::app::Clusters::OperationalState::Structs::ErrorStateStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::OperationalState::Structs::ErrorStateStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalError::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalError
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PhaseList::TypeInfo::DecodableType phaseList;
+ Attributes::CurrentPhase::TypeInfo::DecodableType currentPhase;
+ Attributes::CountdownTime::TypeInfo::DecodableType countdownTime;
+ Attributes::OperationalStateList::TypeInfo::DecodableType operationalStateList;
+ Attributes::OperationalState::TypeInfo::DecodableType operationalState =
+ static_cast<chip::app::Clusters::OperationalState::OperationalStateEnum>(0);
+ Attributes::OperationalError::TypeInfo::DecodableType operationalError;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace OperationalError {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kErrorState = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationalError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Structs::ErrorStateStruct::Type errorState;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationalError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ Structs::ErrorStateStruct::DecodableType errorState;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OperationalError
+namespace OperationCompletion {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCompletionErrorCode = 0,
+ kTotalOperationalTime = 1,
+ kPausedTime = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationCompletion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t completionErrorCode = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> pausedTime;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationCompletion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OperationalState::Id; }
+
+ uint8_t completionErrorCode = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> pausedTime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OperationCompletion
+} // namespace Events
+} // namespace OperationalState
+namespace RvcOperationalState {
+namespace Structs {
+namespace ErrorStateStruct = Clusters::detail::Structs::ErrorStateStruct;
+namespace OperationalStateStruct = Clusters::detail::Structs::OperationalStateStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Pause {
+struct Type;
+struct DecodableType;
+} // namespace Pause
+
+namespace Resume {
+struct Type;
+struct DecodableType;
+} // namespace Resume
+
+namespace OperationalCommandResponse {
+struct Type;
+struct DecodableType;
+} // namespace OperationalCommandResponse
+
+namespace GoHome {
+struct Type;
+struct DecodableType;
+} // namespace GoHome
+
+} // namespace Commands
+
+namespace Commands {
+namespace Pause {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::RvcOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Pause
+namespace Resume {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Resume::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::RvcOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Resume::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Resume
+namespace OperationalCommandResponse {
+enum class Fields : uint8_t
+{
+ kCommandResponseState = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OperationalCommandResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ Structs::ErrorStateStruct::Type commandResponseState;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OperationalCommandResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ Structs::ErrorStateStruct::DecodableType commandResponseState;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OperationalCommandResponse
+namespace GoHome {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GoHome::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::RvcOperationalState::Commands::OperationalCommandResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GoHome::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoHome
+} // namespace Commands
+
+namespace Attributes {
+
+namespace PhaseList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::CharSpan>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<chip::CharSpan>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<chip::CharSpan>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhaseList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhaseList
+namespace CurrentPhase {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPhase::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPhase
+namespace CountdownTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CountdownTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CountdownTime
+namespace OperationalStateList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::RvcOperationalState::Structs::OperationalStateStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::RvcOperationalState::Structs::OperationalStateStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::RvcOperationalState::Structs::OperationalStateStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalStateList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalStateList
+namespace OperationalState {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalState
+namespace OperationalError {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::RvcOperationalState::Structs::ErrorStateStruct::Type;
+ using DecodableType = chip::app::Clusters::RvcOperationalState::Structs::ErrorStateStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::RvcOperationalState::Structs::ErrorStateStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalError::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalError
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PhaseList::TypeInfo::DecodableType phaseList;
+ Attributes::CurrentPhase::TypeInfo::DecodableType currentPhase;
+ Attributes::CountdownTime::TypeInfo::DecodableType countdownTime;
+ Attributes::OperationalStateList::TypeInfo::DecodableType operationalStateList;
+ Attributes::OperationalState::TypeInfo::DecodableType operationalState = static_cast<uint8_t>(0);
+ Attributes::OperationalError::TypeInfo::DecodableType operationalError;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace OperationalError {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kErrorState = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationalError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Structs::ErrorStateStruct::Type errorState;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationalError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ Structs::ErrorStateStruct::DecodableType errorState;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OperationalError
+namespace OperationCompletion {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCompletionErrorCode = 0,
+ kTotalOperationalTime = 1,
+ kPausedTime = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationCompletion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t completionErrorCode = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> pausedTime;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OperationCompletion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RvcOperationalState::Id; }
+
+ uint8_t completionErrorCode = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> pausedTime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OperationCompletion
+} // namespace Events
+} // namespace RvcOperationalState
+namespace ScenesManagement {
+namespace Structs {
+namespace AttributeValuePairStruct {
+enum class Fields : uint8_t
+{
+ kAttributeID = 0,
+ kValueUnsigned8 = 1,
+ kValueSigned8 = 2,
+ kValueUnsigned16 = 3,
+ kValueSigned16 = 4,
+ kValueUnsigned32 = 5,
+ kValueSigned32 = 6,
+ kValueUnsigned64 = 7,
+ kValueSigned64 = 8,
+};
+
+struct Type
+{
+public:
+ chip::AttributeId attributeID = static_cast<chip::AttributeId>(0);
+ Optional<uint8_t> valueUnsigned8;
+ Optional<int8_t> valueSigned8;
+ Optional<uint16_t> valueUnsigned16;
+ Optional<int16_t> valueSigned16;
+ Optional<uint32_t> valueUnsigned32;
+ Optional<int32_t> valueSigned32;
+ Optional<uint64_t> valueUnsigned64;
+ Optional<int64_t> valueSigned64;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AttributeValuePairStruct
+namespace ExtensionFieldSet {
+enum class Fields : uint8_t
+{
+ kClusterID = 0,
+ kAttributeValueList = 1,
+};
+
+struct Type
+{
+public:
+ chip::ClusterId clusterID = static_cast<chip::ClusterId>(0);
+ DataModel::List<const Structs::AttributeValuePairStruct::Type> attributeValueList;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::ClusterId clusterID = static_cast<chip::ClusterId>(0);
+ DataModel::DecodableList<Structs::AttributeValuePairStruct::DecodableType> attributeValueList;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ExtensionFieldSet
+namespace SceneInfoStruct {
+enum class Fields : uint8_t
+{
+ kSceneCount = 0,
+ kCurrentScene = 1,
+ kCurrentGroup = 2,
+ kSceneValid = 3,
+ kRemainingCapacity = 4,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ uint8_t sceneCount = static_cast<uint8_t>(0);
+ uint8_t currentScene = static_cast<uint8_t>(0);
+ chip::GroupId currentGroup = static_cast<chip::GroupId>(0);
+ bool sceneValid = static_cast<bool>(0);
+ uint8_t remainingCapacity = static_cast<uint8_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SceneInfoStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace AddScene {
+struct Type;
+struct DecodableType;
+} // namespace AddScene
+
+namespace AddSceneResponse {
+struct Type;
+struct DecodableType;
+} // namespace AddSceneResponse
+
+namespace ViewScene {
+struct Type;
+struct DecodableType;
+} // namespace ViewScene
+
+namespace ViewSceneResponse {
+struct Type;
+struct DecodableType;
+} // namespace ViewSceneResponse
+
+namespace RemoveScene {
+struct Type;
+struct DecodableType;
+} // namespace RemoveScene
+
+namespace RemoveSceneResponse {
+struct Type;
+struct DecodableType;
+} // namespace RemoveSceneResponse
+
+namespace RemoveAllScenes {
+struct Type;
+struct DecodableType;
+} // namespace RemoveAllScenes
+
+namespace RemoveAllScenesResponse {
+struct Type;
+struct DecodableType;
+} // namespace RemoveAllScenesResponse
+
+namespace StoreScene {
+struct Type;
+struct DecodableType;
+} // namespace StoreScene
+
+namespace StoreSceneResponse {
+struct Type;
+struct DecodableType;
+} // namespace StoreSceneResponse
+
+namespace RecallScene {
+struct Type;
+struct DecodableType;
+} // namespace RecallScene
+
+namespace GetSceneMembership {
+struct Type;
+struct DecodableType;
+} // namespace GetSceneMembership
+
+namespace GetSceneMembershipResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetSceneMembershipResponse
+
+namespace CopyScene {
+struct Type;
+struct DecodableType;
+} // namespace CopyScene
+
+namespace CopySceneResponse {
+struct Type;
+struct DecodableType;
+} // namespace CopySceneResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace AddScene {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kSceneID = 1,
+ kTransitionTime = 2,
+ kSceneName = 3,
+ kExtensionFieldSets = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ uint32_t transitionTime = static_cast<uint32_t>(0);
+ chip::CharSpan sceneName;
+ DataModel::List<const Structs::ExtensionFieldSet::Type> extensionFieldSets;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::AddSceneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ uint32_t transitionTime = static_cast<uint32_t>(0);
+ chip::CharSpan sceneName;
+ DataModel::DecodableList<Structs::ExtensionFieldSet::DecodableType> extensionFieldSets;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddScene
+namespace AddSceneResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+ kSceneID = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddSceneResponse
+namespace ViewScene {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kSceneID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ViewScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::ViewSceneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ViewScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewScene
+namespace ViewSceneResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+ kSceneID = 2,
+ kTransitionTime = 3,
+ kSceneName = 4,
+ kExtensionFieldSets = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ViewSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ Optional<uint32_t> transitionTime;
+ Optional<chip::CharSpan> sceneName;
+ Optional<DataModel::List<const Structs::ExtensionFieldSet::Type>> extensionFieldSets;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ViewSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ Optional<uint32_t> transitionTime;
+ Optional<chip::CharSpan> sceneName;
+ Optional<DataModel::DecodableList<Structs::ExtensionFieldSet::DecodableType>> extensionFieldSets;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ViewSceneResponse
+namespace RemoveScene {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kSceneID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::RemoveSceneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveScene
+namespace RemoveSceneResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+ kSceneID = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveSceneResponse
+namespace RemoveAllScenes {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenes::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::RemoveAllScenesResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenes::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveAllScenes
+namespace RemoveAllScenesResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenesResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenesResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveAllScenesResponse
+namespace StoreScene {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kSceneID = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StoreScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::StoreSceneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StoreScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StoreScene
+namespace StoreSceneResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupID = 1,
+ kSceneID = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StoreSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StoreSceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StoreSceneResponse
+namespace RecallScene {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+ kSceneID = 1,
+ kTransitionTime = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RecallScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> transitionTime;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RecallScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ uint8_t sceneID = static_cast<uint8_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> transitionTime;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RecallScene
+namespace GetSceneMembership {
+enum class Fields : uint8_t
+{
+ kGroupID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetSceneMembership::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::GetSceneMembershipResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetSceneMembership::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSceneMembership
+namespace GetSceneMembershipResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kCapacity = 1,
+ kGroupID = 2,
+ kSceneList = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetSceneMembershipResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint8_t> capacity;
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ Optional<DataModel::List<const uint8_t>> sceneList;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetSceneMembershipResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ DataModel::Nullable<uint8_t> capacity;
+ chip::GroupId groupID = static_cast<chip::GroupId>(0);
+ Optional<DataModel::DecodableList<uint8_t>> sceneList;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSceneMembershipResponse
+namespace CopyScene {
+enum class Fields : uint8_t
+{
+ kMode = 0,
+ kGroupIdentifierFrom = 1,
+ kSceneIdentifierFrom = 2,
+ kGroupIdentifierTo = 3,
+ kSceneIdentifierTo = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CopyScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::BitMask<CopyModeBitmap> mode = static_cast<chip::BitMask<CopyModeBitmap>>(0);
+ chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
+ uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);
+ chip::GroupId groupIdentifierTo = static_cast<chip::GroupId>(0);
+ uint8_t sceneIdentifierTo = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ScenesManagement::Commands::CopySceneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CopyScene::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ chip::BitMask<CopyModeBitmap> mode = static_cast<chip::BitMask<CopyModeBitmap>>(0);
+ chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
+ uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);
+ chip::GroupId groupIdentifierTo = static_cast<chip::GroupId>(0);
+ uint8_t sceneIdentifierTo = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CopyScene
+namespace CopySceneResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kGroupIdentifierFrom = 1,
+ kSceneIdentifierFrom = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CopySceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
+ uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CopySceneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
+ uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CopySceneResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace LastConfiguredBy {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::NodeId>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::NodeId>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::NodeId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LastConfiguredBy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LastConfiguredBy
+namespace SceneTableSize {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SceneTableSize::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SceneTableSize
+namespace FabricSceneInfo {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ScenesManagement::Structs::SceneInfoStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ScenesManagement::Structs::SceneInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ScenesManagement::Structs::SceneInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FabricSceneInfo::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FabricSceneInfo
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ScenesManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::LastConfiguredBy::TypeInfo::DecodableType lastConfiguredBy;
+ Attributes::SceneTableSize::TypeInfo::DecodableType sceneTableSize = static_cast<uint16_t>(0);
+ Attributes::FabricSceneInfo::TypeInfo::DecodableType fabricSceneInfo;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ScenesManagement
+namespace HepaFilterMonitoring {
+namespace Structs {
+namespace ReplacementProductStruct {
+enum class Fields : uint8_t
+{
+ kProductIdentifierType = 0,
+ kProductIdentifierValue = 1,
+};
+
+struct Type
+{
+public:
+ ProductIdentifierTypeEnum productIdentifierType = static_cast<ProductIdentifierTypeEnum>(0);
+ chip::CharSpan productIdentifierValue;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ReplacementProductStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ResetCondition {
+struct Type;
+struct DecodableType;
+} // namespace ResetCondition
+
+} // namespace Commands
+
+namespace Commands {
+namespace ResetCondition {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetCondition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetCondition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCondition
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Condition {
+struct TypeInfo
+{
+ using Type = chip::Percent;
+ using DecodableType = chip::Percent;
+ using DecodableArgType = chip::Percent;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Condition::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Condition
+namespace DegradationDirection {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::HepaFilterMonitoring::DegradationDirectionEnum;
+ using DecodableType = chip::app::Clusters::HepaFilterMonitoring::DegradationDirectionEnum;
+ using DecodableArgType = chip::app::Clusters::HepaFilterMonitoring::DegradationDirectionEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DegradationDirection::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DegradationDirection
+namespace ChangeIndication {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::HepaFilterMonitoring::ChangeIndicationEnum;
+ using DecodableType = chip::app::Clusters::HepaFilterMonitoring::ChangeIndicationEnum;
+ using DecodableArgType = chip::app::Clusters::HepaFilterMonitoring::ChangeIndicationEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChangeIndication::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ChangeIndication
+namespace InPlaceIndicator {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InPlaceIndicator::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InPlaceIndicator
+namespace LastChangedTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LastChangedTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LastChangedTime
+namespace ReplacementProductList {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::HepaFilterMonitoring::Structs::ReplacementProductStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::HepaFilterMonitoring::Structs::ReplacementProductStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::HepaFilterMonitoring::Structs::ReplacementProductStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ReplacementProductList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ReplacementProductList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::HepaFilterMonitoring::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Condition::TypeInfo::DecodableType condition = static_cast<chip::Percent>(0);
+ Attributes::DegradationDirection::TypeInfo::DecodableType degradationDirection =
+ static_cast<chip::app::Clusters::HepaFilterMonitoring::DegradationDirectionEnum>(0);
+ Attributes::ChangeIndication::TypeInfo::DecodableType changeIndication =
+ static_cast<chip::app::Clusters::HepaFilterMonitoring::ChangeIndicationEnum>(0);
+ Attributes::InPlaceIndicator::TypeInfo::DecodableType inPlaceIndicator = static_cast<bool>(0);
+ Attributes::LastChangedTime::TypeInfo::DecodableType lastChangedTime;
+ Attributes::ReplacementProductList::TypeInfo::DecodableType replacementProductList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace HepaFilterMonitoring
+namespace ActivatedCarbonFilterMonitoring {
+namespace Structs {
+namespace ReplacementProductStruct {
+enum class Fields : uint8_t
+{
+ kProductIdentifierType = 0,
+ kProductIdentifierValue = 1,
+};
+
+struct Type
+{
+public:
+ ProductIdentifierTypeEnum productIdentifierType = static_cast<ProductIdentifierTypeEnum>(0);
+ chip::CharSpan productIdentifierValue;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ReplacementProductStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ResetCondition {
+struct Type;
+struct DecodableType;
+} // namespace ResetCondition
+
+} // namespace Commands
+
+namespace Commands {
+namespace ResetCondition {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetCondition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetCondition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetCondition
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Condition {
+struct TypeInfo
+{
+ using Type = chip::Percent;
+ using DecodableType = chip::Percent;
+ using DecodableArgType = chip::Percent;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Condition::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Condition
+namespace DegradationDirection {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ActivatedCarbonFilterMonitoring::DegradationDirectionEnum;
+ using DecodableType = chip::app::Clusters::ActivatedCarbonFilterMonitoring::DegradationDirectionEnum;
+ using DecodableArgType = chip::app::Clusters::ActivatedCarbonFilterMonitoring::DegradationDirectionEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DegradationDirection::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DegradationDirection
+namespace ChangeIndication {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ActivatedCarbonFilterMonitoring::ChangeIndicationEnum;
+ using DecodableType = chip::app::Clusters::ActivatedCarbonFilterMonitoring::ChangeIndicationEnum;
+ using DecodableArgType = chip::app::Clusters::ActivatedCarbonFilterMonitoring::ChangeIndicationEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChangeIndication::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ChangeIndication
+namespace InPlaceIndicator {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InPlaceIndicator::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InPlaceIndicator
+namespace LastChangedTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LastChangedTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LastChangedTime
+namespace ReplacementProductList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<
+ const chip::app::Clusters::ActivatedCarbonFilterMonitoring::Structs::ReplacementProductStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ActivatedCarbonFilterMonitoring::Structs::ReplacementProductStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ActivatedCarbonFilterMonitoring::Structs::ReplacementProductStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ReplacementProductList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ReplacementProductList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ActivatedCarbonFilterMonitoring::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Condition::TypeInfo::DecodableType condition = static_cast<chip::Percent>(0);
+ Attributes::DegradationDirection::TypeInfo::DecodableType degradationDirection =
+ static_cast<chip::app::Clusters::ActivatedCarbonFilterMonitoring::DegradationDirectionEnum>(0);
+ Attributes::ChangeIndication::TypeInfo::DecodableType changeIndication =
+ static_cast<chip::app::Clusters::ActivatedCarbonFilterMonitoring::ChangeIndicationEnum>(0);
+ Attributes::InPlaceIndicator::TypeInfo::DecodableType inPlaceIndicator = static_cast<bool>(0);
+ Attributes::LastChangedTime::TypeInfo::DecodableType lastChangedTime;
+ Attributes::ReplacementProductList::TypeInfo::DecodableType replacementProductList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ActivatedCarbonFilterMonitoring
+namespace BooleanStateConfiguration {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SuppressAlarm {
+struct Type;
+struct DecodableType;
+} // namespace SuppressAlarm
+
+namespace EnableDisableAlarm {
+struct Type;
+struct DecodableType;
+} // namespace EnableDisableAlarm
+
+} // namespace Commands
+
+namespace Commands {
+namespace SuppressAlarm {
+enum class Fields : uint8_t
+{
+ kAlarmsToSuppress = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SuppressAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ chip::BitMask<AlarmModeBitmap> alarmsToSuppress = static_cast<chip::BitMask<AlarmModeBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SuppressAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ chip::BitMask<AlarmModeBitmap> alarmsToSuppress = static_cast<chip::BitMask<AlarmModeBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SuppressAlarm
+namespace EnableDisableAlarm {
+enum class Fields : uint8_t
+{
+ kAlarmsToEnableDisable = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnableDisableAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ chip::BitMask<AlarmModeBitmap> alarmsToEnableDisable = static_cast<chip::BitMask<AlarmModeBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnableDisableAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ chip::BitMask<AlarmModeBitmap> alarmsToEnableDisable = static_cast<chip::BitMask<AlarmModeBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableDisableAlarm
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CurrentSensitivityLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentSensitivityLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentSensitivityLevel
+namespace SupportedSensitivityLevels {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedSensitivityLevels::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedSensitivityLevels
+namespace DefaultSensitivityLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultSensitivityLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultSensitivityLevel
+namespace AlarmsActive {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsActive::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AlarmsActive
+namespace AlarmsSuppressed {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsSuppressed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AlarmsSuppressed
+namespace AlarmsEnabled {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AlarmsEnabled
+namespace AlarmsSupported {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AlarmsSupported
+namespace SensorFault {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SensorFault::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SensorFault
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CurrentSensitivityLevel::TypeInfo::DecodableType currentSensitivityLevel = static_cast<uint8_t>(0);
+ Attributes::SupportedSensitivityLevels::TypeInfo::DecodableType supportedSensitivityLevels = static_cast<uint8_t>(0);
+ Attributes::DefaultSensitivityLevel::TypeInfo::DecodableType defaultSensitivityLevel = static_cast<uint8_t>(0);
+ Attributes::AlarmsActive::TypeInfo::DecodableType alarmsActive =
+ static_cast<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>(0);
+ Attributes::AlarmsSuppressed::TypeInfo::DecodableType alarmsSuppressed =
+ static_cast<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>(0);
+ Attributes::AlarmsEnabled::TypeInfo::DecodableType alarmsEnabled =
+ static_cast<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>(0);
+ Attributes::AlarmsSupported::TypeInfo::DecodableType alarmsSupported =
+ static_cast<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>(0);
+ Attributes::SensorFault::TypeInfo::DecodableType sensorFault =
+ static_cast<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace AlarmsStateChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kAlarmsActive = 0,
+ kAlarmsSuppressed = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AlarmsStateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<AlarmModeBitmap> alarmsActive = static_cast<chip::BitMask<AlarmModeBitmap>>(0);
+ Optional<chip::BitMask<AlarmModeBitmap>> alarmsSuppressed;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AlarmsStateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ chip::BitMask<AlarmModeBitmap> alarmsActive = static_cast<chip::BitMask<AlarmModeBitmap>>(0);
+ Optional<chip::BitMask<AlarmModeBitmap>> alarmsSuppressed;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AlarmsStateChanged
+namespace SensorFault {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSensorFault = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SensorFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<SensorFaultBitmap> sensorFault = static_cast<chip::BitMask<SensorFaultBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SensorFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::BooleanStateConfiguration::Id; }
+
+ chip::BitMask<SensorFaultBitmap> sensorFault = static_cast<chip::BitMask<SensorFaultBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SensorFault
+} // namespace Events
+} // namespace BooleanStateConfiguration
+namespace ValveConfigurationAndControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Open {
+struct Type;
+struct DecodableType;
+} // namespace Open
+
+namespace Close {
+struct Type;
+struct DecodableType;
+} // namespace Close
+
+} // namespace Commands
+
+namespace Commands {
+namespace Open {
+enum class Fields : uint8_t
+{
+ kOpenDuration = 0,
+ kTargetLevel = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Open::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ Optional<DataModel::Nullable<uint32_t>> openDuration;
+ Optional<chip::Percent> targetLevel;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Open::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ Optional<DataModel::Nullable<uint32_t>> openDuration;
+ Optional<chip::Percent> targetLevel;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Open
+namespace Close {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Close::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Close::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Close
+} // namespace Commands
+
+namespace Attributes {
+
+namespace OpenDuration {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OpenDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OpenDuration
+namespace DefaultOpenDuration {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultOpenDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultOpenDuration
+namespace AutoCloseTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AutoCloseTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AutoCloseTime
+namespace RemainingDuration {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RemainingDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RemainingDuration
+namespace CurrentState {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentState
+namespace TargetState {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TargetState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TargetState
+namespace CurrentLevel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentLevel
+namespace TargetLevel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TargetLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TargetLevel
+namespace DefaultOpenLevel {
+struct TypeInfo
+{
+ using Type = chip::Percent;
+ using DecodableType = chip::Percent;
+ using DecodableArgType = chip::Percent;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultOpenLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultOpenLevel
+namespace ValveFault {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ValveFault::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ValveFault
+namespace LevelStep {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelStep::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelStep
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::OpenDuration::TypeInfo::DecodableType openDuration;
+ Attributes::DefaultOpenDuration::TypeInfo::DecodableType defaultOpenDuration;
+ Attributes::AutoCloseTime::TypeInfo::DecodableType autoCloseTime;
+ Attributes::RemainingDuration::TypeInfo::DecodableType remainingDuration;
+ Attributes::CurrentState::TypeInfo::DecodableType currentState;
+ Attributes::TargetState::TypeInfo::DecodableType targetState;
+ Attributes::CurrentLevel::TypeInfo::DecodableType currentLevel;
+ Attributes::TargetLevel::TypeInfo::DecodableType targetLevel;
+ Attributes::DefaultOpenLevel::TypeInfo::DecodableType defaultOpenLevel = static_cast<chip::Percent>(0);
+ Attributes::ValveFault::TypeInfo::DecodableType valveFault =
+ static_cast<chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>>(0);
+ Attributes::LevelStep::TypeInfo::DecodableType levelStep = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace ValveStateChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kValveState = 0,
+ kValveLevel = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ValveStateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ ValveStateEnum valveState = static_cast<ValveStateEnum>(0);
+ Optional<chip::Percent> valveLevel;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ValveStateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ ValveStateEnum valveState = static_cast<ValveStateEnum>(0);
+ Optional<chip::Percent> valveLevel;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ValveStateChanged
+namespace ValveFault {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kValveFault = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ValveFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<ValveFaultBitmap> valveFault = static_cast<chip::BitMask<ValveFaultBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ValveFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; }
+
+ chip::BitMask<ValveFaultBitmap> valveFault = static_cast<chip::BitMask<ValveFaultBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ValveFault
+} // namespace Events
+} // namespace ValveConfigurationAndControl
+namespace ElectricalPowerMeasurement {
+namespace Structs {
+namespace MeasurementAccuracyRangeStruct = Clusters::detail::Structs::MeasurementAccuracyRangeStruct;
+namespace MeasurementAccuracyStruct = Clusters::detail::Structs::MeasurementAccuracyStruct;
+namespace HarmonicMeasurementStruct {
+enum class Fields : uint8_t
+{
+ kOrder = 0,
+ kMeasurement = 1,
+};
+
+struct Type
+{
+public:
+ uint8_t order = static_cast<uint8_t>(0);
+ DataModel::Nullable<int64_t> measurement;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace HarmonicMeasurementStruct
+namespace MeasurementRangeStruct {
+enum class Fields : uint8_t
+{
+ kMeasurementType = 0,
+ kMin = 1,
+ kMax = 2,
+ kStartTimestamp = 3,
+ kEndTimestamp = 4,
+ kMinTimestamp = 5,
+ kMaxTimestamp = 6,
+ kStartSystime = 7,
+ kEndSystime = 8,
+ kMinSystime = 9,
+ kMaxSystime = 10,
+};
+
+struct Type
+{
+public:
+ MeasurementTypeEnum measurementType = static_cast<MeasurementTypeEnum>(0);
+ int64_t min = static_cast<int64_t>(0);
+ int64_t max = static_cast<int64_t>(0);
+ Optional<uint32_t> startTimestamp;
+ Optional<uint32_t> endTimestamp;
+ Optional<uint32_t> minTimestamp;
+ Optional<uint32_t> maxTimestamp;
+ Optional<uint64_t> startSystime;
+ Optional<uint64_t> endSystime;
+ Optional<uint64_t> minSystime;
+ Optional<uint64_t> maxSystime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MeasurementRangeStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace PowerMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ElectricalPowerMeasurement::PowerModeEnum;
+ using DecodableType = chip::app::Clusters::ElectricalPowerMeasurement::PowerModeEnum;
+ using DecodableArgType = chip::app::Clusters::ElectricalPowerMeasurement::PowerModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PowerMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PowerMode
+namespace NumberOfMeasurementTypes {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfMeasurementTypes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfMeasurementTypes
+namespace Accuracy {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementAccuracyStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementAccuracyStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementAccuracyStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Accuracy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Accuracy
+namespace Ranges {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementRangeStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementRangeStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementRangeStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Ranges::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Ranges
+namespace Voltage {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Voltage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Voltage
+namespace ActiveCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveCurrent
+namespace ReactiveCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ReactiveCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ReactiveCurrent
+namespace ApparentCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ApparentCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ApparentCurrent
+namespace ActivePower {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActivePower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActivePower
+namespace ReactivePower {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ReactivePower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ReactivePower
+namespace ApparentPower {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ApparentPower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ApparentPower
+namespace RMSVoltage {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RMSVoltage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RMSVoltage
+namespace RMSCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RMSCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RMSCurrent
+namespace RMSPower {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RMSPower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RMSPower
+namespace Frequency {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Frequency::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Frequency
+namespace HarmonicCurrents {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::DataModel::List<
+ const chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::Type>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::DecodableType>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::DecodableType>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HarmonicCurrents::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HarmonicCurrents
+namespace HarmonicPhases {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::DataModel::List<
+ const chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::Type>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::DecodableType>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::DecodableType>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HarmonicPhases::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HarmonicPhases
+namespace PowerFactor {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PowerFactor::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PowerFactor
+namespace NeutralCurrent {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NeutralCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NeutralCurrent
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PowerMode::TypeInfo::DecodableType powerMode =
+ static_cast<chip::app::Clusters::ElectricalPowerMeasurement::PowerModeEnum>(0);
+ Attributes::NumberOfMeasurementTypes::TypeInfo::DecodableType numberOfMeasurementTypes = static_cast<uint8_t>(0);
+ Attributes::Accuracy::TypeInfo::DecodableType accuracy;
+ Attributes::Ranges::TypeInfo::DecodableType ranges;
+ Attributes::Voltage::TypeInfo::DecodableType voltage;
+ Attributes::ActiveCurrent::TypeInfo::DecodableType activeCurrent;
+ Attributes::ReactiveCurrent::TypeInfo::DecodableType reactiveCurrent;
+ Attributes::ApparentCurrent::TypeInfo::DecodableType apparentCurrent;
+ Attributes::ActivePower::TypeInfo::DecodableType activePower;
+ Attributes::ReactivePower::TypeInfo::DecodableType reactivePower;
+ Attributes::ApparentPower::TypeInfo::DecodableType apparentPower;
+ Attributes::RMSVoltage::TypeInfo::DecodableType RMSVoltage;
+ Attributes::RMSCurrent::TypeInfo::DecodableType RMSCurrent;
+ Attributes::RMSPower::TypeInfo::DecodableType RMSPower;
+ Attributes::Frequency::TypeInfo::DecodableType frequency;
+ Attributes::HarmonicCurrents::TypeInfo::DecodableType harmonicCurrents;
+ Attributes::HarmonicPhases::TypeInfo::DecodableType harmonicPhases;
+ Attributes::PowerFactor::TypeInfo::DecodableType powerFactor;
+ Attributes::NeutralCurrent::TypeInfo::DecodableType neutralCurrent;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace MeasurementPeriodRanges {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kRanges = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MeasurementPeriodRanges::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const Structs::MeasurementRangeStruct::Type> ranges;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MeasurementPeriodRanges::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalPowerMeasurement::Id; }
+
+ DataModel::DecodableList<Structs::MeasurementRangeStruct::DecodableType> ranges;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MeasurementPeriodRanges
+} // namespace Events
+} // namespace ElectricalPowerMeasurement
+namespace ElectricalEnergyMeasurement {
+namespace Structs {
+namespace MeasurementAccuracyRangeStruct = Clusters::detail::Structs::MeasurementAccuracyRangeStruct;
+namespace MeasurementAccuracyStruct = Clusters::detail::Structs::MeasurementAccuracyStruct;
+namespace CumulativeEnergyResetStruct {
+enum class Fields : uint8_t
+{
+ kImportedResetTimestamp = 0,
+ kExportedResetTimestamp = 1,
+ kImportedResetSystime = 2,
+ kExportedResetSystime = 3,
+};
+
+struct Type
+{
+public:
+ Optional<DataModel::Nullable<uint32_t>> importedResetTimestamp;
+ Optional<DataModel::Nullable<uint32_t>> exportedResetTimestamp;
+ Optional<DataModel::Nullable<uint64_t>> importedResetSystime;
+ Optional<DataModel::Nullable<uint64_t>> exportedResetSystime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace CumulativeEnergyResetStruct
+namespace EnergyMeasurementStruct {
+enum class Fields : uint8_t
+{
+ kEnergy = 0,
+ kStartTimestamp = 1,
+ kEndTimestamp = 2,
+ kStartSystime = 3,
+ kEndSystime = 4,
+};
+
+struct Type
+{
+public:
+ int64_t energy = static_cast<int64_t>(0);
+ Optional<uint32_t> startTimestamp;
+ Optional<uint32_t> endTimestamp;
+ Optional<uint64_t> startSystime;
+ Optional<uint64_t> endSystime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace EnergyMeasurementStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace Accuracy {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ElectricalEnergyMeasurement::Structs::MeasurementAccuracyStruct::Type;
+ using DecodableType = chip::app::Clusters::ElectricalEnergyMeasurement::Structs::MeasurementAccuracyStruct::DecodableType;
+ using DecodableArgType =
+ const chip::app::Clusters::ElectricalEnergyMeasurement::Structs::MeasurementAccuracyStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Accuracy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Accuracy
+namespace CumulativeEnergyImported {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CumulativeEnergyImported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CumulativeEnergyImported
+namespace CumulativeEnergyExported {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CumulativeEnergyExported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CumulativeEnergyExported
+namespace PeriodicEnergyImported {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeriodicEnergyImported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeriodicEnergyImported
+namespace PeriodicEnergyExported {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeriodicEnergyExported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeriodicEnergyExported
+namespace CumulativeEnergyReset {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::CumulativeEnergyResetStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::CumulativeEnergyResetStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ElectricalEnergyMeasurement::Structs::CumulativeEnergyResetStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CumulativeEnergyReset::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CumulativeEnergyReset
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Accuracy::TypeInfo::DecodableType accuracy;
+ Attributes::CumulativeEnergyImported::TypeInfo::DecodableType cumulativeEnergyImported;
+ Attributes::CumulativeEnergyExported::TypeInfo::DecodableType cumulativeEnergyExported;
+ Attributes::PeriodicEnergyImported::TypeInfo::DecodableType periodicEnergyImported;
+ Attributes::PeriodicEnergyExported::TypeInfo::DecodableType periodicEnergyExported;
+ Attributes::CumulativeEnergyReset::TypeInfo::DecodableType cumulativeEnergyReset;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace CumulativeEnergyMeasured {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kEnergyImported = 0,
+ kEnergyExported = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::CumulativeEnergyMeasured::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Optional<Structs::EnergyMeasurementStruct::Type> energyImported;
+ Optional<Structs::EnergyMeasurementStruct::Type> energyExported;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::CumulativeEnergyMeasured::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+
+ Optional<Structs::EnergyMeasurementStruct::DecodableType> energyImported;
+ Optional<Structs::EnergyMeasurementStruct::DecodableType> energyExported;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace CumulativeEnergyMeasured
+namespace PeriodicEnergyMeasured {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kEnergyImported = 0,
+ kEnergyExported = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PeriodicEnergyMeasured::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Optional<Structs::EnergyMeasurementStruct::Type> energyImported;
+ Optional<Structs::EnergyMeasurementStruct::Type> energyExported;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PeriodicEnergyMeasured::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ElectricalEnergyMeasurement::Id; }
+
+ Optional<Structs::EnergyMeasurementStruct::DecodableType> energyImported;
+ Optional<Structs::EnergyMeasurementStruct::DecodableType> energyExported;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PeriodicEnergyMeasured
+} // namespace Events
+} // namespace ElectricalEnergyMeasurement
+namespace WaterHeaterManagement {
+namespace Structs {
+namespace WaterHeaterBoostInfoStruct {
+enum class Fields : uint8_t
+{
+ kDuration = 0,
+ kOneShot = 1,
+ kEmergencyBoost = 2,
+ kTemporarySetpoint = 3,
+ kTargetPercentage = 4,
+ kTargetReheat = 5,
+};
+
+struct Type
+{
+public:
+ uint32_t duration = static_cast<uint32_t>(0);
+ Optional<bool> oneShot;
+ Optional<bool> emergencyBoost;
+ Optional<int16_t> temporarySetpoint;
+ Optional<chip::Percent> targetPercentage;
+ Optional<chip::Percent> targetReheat;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace WaterHeaterBoostInfoStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Boost {
+struct Type;
+struct DecodableType;
+} // namespace Boost
+
+namespace CancelBoost {
+struct Type;
+struct DecodableType;
+} // namespace CancelBoost
+
+} // namespace Commands
+
+namespace Commands {
+namespace Boost {
+enum class Fields : uint8_t
+{
+ kBoostInfo = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Boost::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ Structs::WaterHeaterBoostInfoStruct::Type boostInfo;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Boost::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ Structs::WaterHeaterBoostInfoStruct::DecodableType boostInfo;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Boost
+namespace CancelBoost {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CancelBoost::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CancelBoost::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelBoost
+} // namespace Commands
+
+namespace Attributes {
+
+namespace HeaterTypes {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HeaterTypes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HeaterTypes
+namespace HeatDemand {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HeatDemand::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HeatDemand
+namespace TankVolume {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TankVolume::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TankVolume
+namespace EstimatedHeatRequired {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EstimatedHeatRequired::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EstimatedHeatRequired
+namespace TankPercentage {
+struct TypeInfo
+{
+ using Type = chip::Percent;
+ using DecodableType = chip::Percent;
+ using DecodableArgType = chip::Percent;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TankPercentage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TankPercentage
+namespace BoostState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::WaterHeaterManagement::BoostStateEnum;
+ using DecodableType = chip::app::Clusters::WaterHeaterManagement::BoostStateEnum;
+ using DecodableArgType = chip::app::Clusters::WaterHeaterManagement::BoostStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BoostState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BoostState
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::HeaterTypes::TypeInfo::DecodableType heaterTypes =
+ static_cast<chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>>(0);
+ Attributes::HeatDemand::TypeInfo::DecodableType heatDemand =
+ static_cast<chip::BitMask<chip::app::Clusters::WaterHeaterManagement::WaterHeaterHeatSourceBitmap>>(0);
+ Attributes::TankVolume::TypeInfo::DecodableType tankVolume = static_cast<uint16_t>(0);
+ Attributes::EstimatedHeatRequired::TypeInfo::DecodableType estimatedHeatRequired = static_cast<int64_t>(0);
+ Attributes::TankPercentage::TypeInfo::DecodableType tankPercentage = static_cast<chip::Percent>(0);
+ Attributes::BoostState::TypeInfo::DecodableType boostState =
+ static_cast<chip::app::Clusters::WaterHeaterManagement::BoostStateEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace BoostStarted {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kBoostInfo = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BoostStarted::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Structs::WaterHeaterBoostInfoStruct::Type boostInfo;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BoostStarted::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ Structs::WaterHeaterBoostInfoStruct::DecodableType boostInfo;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace BoostStarted
+namespace BoostEnded {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BoostEnded::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::BoostEnded::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace BoostEnded
+} // namespace Events
+} // namespace WaterHeaterManagement
+namespace DemandResponseLoadControl {
+namespace Structs {
+namespace HeatingSourceControlStruct {
+enum class Fields : uint8_t
+{
+ kHeatingSource = 0,
+};
+
+struct Type
+{
+public:
+ HeatingSourceEnum heatingSource = static_cast<HeatingSourceEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace HeatingSourceControlStruct
+namespace PowerSavingsControlStruct {
+enum class Fields : uint8_t
+{
+ kPowerSavings = 0,
+};
+
+struct Type
+{
+public:
+ chip::Percent powerSavings = static_cast<chip::Percent>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace PowerSavingsControlStruct
+namespace DutyCycleControlStruct {
+enum class Fields : uint8_t
+{
+ kDutyCycle = 0,
+};
+
+struct Type
+{
+public:
+ chip::Percent dutyCycle = static_cast<chip::Percent>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace DutyCycleControlStruct
+namespace AverageLoadControlStruct {
+enum class Fields : uint8_t
+{
+ kLoadAdjustment = 0,
+};
+
+struct Type
+{
+public:
+ int8_t loadAdjustment = static_cast<int8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AverageLoadControlStruct
+namespace TemperatureControlStruct {
+enum class Fields : uint8_t
+{
+ kCoolingTempOffset = 0,
+ kHeatingtTempOffset = 1,
+ kCoolingTempSetpoint = 2,
+ kHeatingTempSetpoint = 3,
+};
+
+struct Type
+{
+public:
+ Optional<DataModel::Nullable<uint16_t>> coolingTempOffset;
+ Optional<DataModel::Nullable<uint16_t>> heatingtTempOffset;
+ Optional<DataModel::Nullable<int16_t>> coolingTempSetpoint;
+ Optional<DataModel::Nullable<int16_t>> heatingTempSetpoint;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TemperatureControlStruct
+namespace LoadControlEventTransitionStruct {
+enum class Fields : uint8_t
+{
+ kDuration = 0,
+ kControl = 1,
+ kTemperatureControl = 2,
+ kAverageLoadControl = 3,
+ kDutyCycleControl = 4,
+ kPowerSavingsControl = 5,
+ kHeatingSourceControl = 6,
+};
+
+struct Type
+{
+public:
+ uint16_t duration = static_cast<uint16_t>(0);
+ chip::BitMask<EventTransitionControlBitmap> control = static_cast<chip::BitMask<EventTransitionControlBitmap>>(0);
+ Optional<Structs::TemperatureControlStruct::Type> temperatureControl;
+ Optional<Structs::AverageLoadControlStruct::Type> averageLoadControl;
+ Optional<Structs::DutyCycleControlStruct::Type> dutyCycleControl;
+ Optional<Structs::PowerSavingsControlStruct::Type> powerSavingsControl;
+ Optional<Structs::HeatingSourceControlStruct::Type> heatingSourceControl;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace LoadControlEventTransitionStruct
+namespace LoadControlEventStruct {
+enum class Fields : uint8_t
+{
+ kEventID = 0,
+ kProgramID = 1,
+ kControl = 2,
+ kDeviceClass = 3,
+ kEnrollmentGroup = 4,
+ kCriticality = 5,
+ kStartTime = 6,
+ kTransitions = 7,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan eventID;
+ DataModel::Nullable<chip::ByteSpan> programID;
+ chip::BitMask<EventControlBitmap> control = static_cast<chip::BitMask<EventControlBitmap>>(0);
+ chip::BitMask<DeviceClassBitmap> deviceClass = static_cast<chip::BitMask<DeviceClassBitmap>>(0);
+ Optional<uint8_t> enrollmentGroup;
+ CriticalityLevelEnum criticality = static_cast<CriticalityLevelEnum>(0);
+ DataModel::Nullable<uint32_t> startTime;
+ DataModel::List<const Structs::LoadControlEventTransitionStruct::Type> transitions;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::ByteSpan eventID;
+ DataModel::Nullable<chip::ByteSpan> programID;
+ chip::BitMask<EventControlBitmap> control = static_cast<chip::BitMask<EventControlBitmap>>(0);
+ chip::BitMask<DeviceClassBitmap> deviceClass = static_cast<chip::BitMask<DeviceClassBitmap>>(0);
+ Optional<uint8_t> enrollmentGroup;
+ CriticalityLevelEnum criticality = static_cast<CriticalityLevelEnum>(0);
+ DataModel::Nullable<uint32_t> startTime;
+ DataModel::DecodableList<Structs::LoadControlEventTransitionStruct::DecodableType> transitions;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace LoadControlEventStruct
+namespace LoadControlProgramStruct {
+enum class Fields : uint8_t
+{
+ kProgramID = 0,
+ kName = 1,
+ kEnrollmentGroup = 2,
+ kRandomStartMinutes = 3,
+ kRandomDurationMinutes = 4,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan programID;
+ chip::CharSpan name;
+ DataModel::Nullable<uint8_t> enrollmentGroup;
+ DataModel::Nullable<uint8_t> randomStartMinutes;
+ DataModel::Nullable<uint8_t> randomDurationMinutes;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace LoadControlProgramStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace RegisterLoadControlProgramRequest {
+struct Type;
+struct DecodableType;
+} // namespace RegisterLoadControlProgramRequest
+
+namespace UnregisterLoadControlProgramRequest {
+struct Type;
+struct DecodableType;
+} // namespace UnregisterLoadControlProgramRequest
+
+namespace AddLoadControlEventRequest {
+struct Type;
+struct DecodableType;
+} // namespace AddLoadControlEventRequest
+
+namespace RemoveLoadControlEventRequest {
+struct Type;
+struct DecodableType;
+} // namespace RemoveLoadControlEventRequest
+
+namespace ClearLoadControlEventsRequest {
+struct Type;
+struct DecodableType;
+} // namespace ClearLoadControlEventsRequest
+
+} // namespace Commands
+
+namespace Commands {
+namespace RegisterLoadControlProgramRequest {
+enum class Fields : uint8_t
+{
+ kLoadControlProgram = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RegisterLoadControlProgramRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ Structs::LoadControlProgramStruct::Type loadControlProgram;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RegisterLoadControlProgramRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ Structs::LoadControlProgramStruct::DecodableType loadControlProgram;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RegisterLoadControlProgramRequest
+namespace UnregisterLoadControlProgramRequest {
+enum class Fields : uint8_t
+{
+ kLoadControlProgramID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UnregisterLoadControlProgramRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ chip::ByteSpan loadControlProgramID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UnregisterLoadControlProgramRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ chip::ByteSpan loadControlProgramID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnregisterLoadControlProgramRequest
+namespace AddLoadControlEventRequest {
+enum class Fields : uint8_t
+{
+ kEvent = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddLoadControlEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ Structs::LoadControlEventStruct::Type event;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddLoadControlEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ Structs::LoadControlEventStruct::DecodableType event;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddLoadControlEventRequest
+namespace RemoveLoadControlEventRequest {
+enum class Fields : uint8_t
+{
+ kEventID = 0,
+ kCancelControl = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveLoadControlEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ chip::ByteSpan eventID;
+ chip::BitMask<CancelControlBitmap> cancelControl = static_cast<chip::BitMask<CancelControlBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveLoadControlEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ chip::ByteSpan eventID;
+ chip::BitMask<CancelControlBitmap> cancelControl = static_cast<chip::BitMask<CancelControlBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveLoadControlEventRequest
+namespace ClearLoadControlEventsRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearLoadControlEventsRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearLoadControlEventsRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearLoadControlEventsRequest
+} // namespace Commands
+
+namespace Attributes {
+
+namespace LoadControlPrograms {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlProgramStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlProgramStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlProgramStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LoadControlPrograms::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LoadControlPrograms
+namespace NumberOfLoadControlPrograms {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfLoadControlPrograms::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfLoadControlPrograms
+namespace Events {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Events::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Events
+namespace ActiveEvents {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveEvents::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveEvents
+namespace NumberOfEventsPerProgram {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfEventsPerProgram::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfEventsPerProgram
+namespace NumberOfTransitions {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfTransitions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfTransitions
+namespace DefaultRandomStart {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultRandomStart::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultRandomStart
+namespace DefaultRandomDuration {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultRandomDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultRandomDuration
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::LoadControlPrograms::TypeInfo::DecodableType loadControlPrograms;
+ Attributes::NumberOfLoadControlPrograms::TypeInfo::DecodableType numberOfLoadControlPrograms = static_cast<uint8_t>(0);
+ Attributes::Events::TypeInfo::DecodableType events;
+ Attributes::ActiveEvents::TypeInfo::DecodableType activeEvents;
+ Attributes::NumberOfEventsPerProgram::TypeInfo::DecodableType numberOfEventsPerProgram = static_cast<uint8_t>(0);
+ Attributes::NumberOfTransitions::TypeInfo::DecodableType numberOfTransitions = static_cast<uint8_t>(0);
+ Attributes::DefaultRandomStart::TypeInfo::DecodableType defaultRandomStart = static_cast<uint8_t>(0);
+ Attributes::DefaultRandomDuration::TypeInfo::DecodableType defaultRandomDuration = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace LoadControlEventStatusChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kEventID = 0,
+ kTransitionIndex = 1,
+ kStatus = 2,
+ kCriticality = 3,
+ kControl = 4,
+ kTemperatureControl = 5,
+ kAverageLoadControl = 6,
+ kDutyCycleControl = 7,
+ kPowerSavingsControl = 8,
+ kHeatingSourceControl = 9,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LoadControlEventStatusChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::ByteSpan eventID;
+ DataModel::Nullable<uint8_t> transitionIndex;
+ LoadControlEventStatusEnum status = static_cast<LoadControlEventStatusEnum>(0);
+ CriticalityLevelEnum criticality = static_cast<CriticalityLevelEnum>(0);
+ chip::BitMask<EventControlBitmap> control = static_cast<chip::BitMask<EventControlBitmap>>(0);
+ Optional<DataModel::Nullable<Structs::TemperatureControlStruct::Type>> temperatureControl;
+ Optional<DataModel::Nullable<Structs::AverageLoadControlStruct::Type>> averageLoadControl;
+ Optional<DataModel::Nullable<Structs::DutyCycleControlStruct::Type>> dutyCycleControl;
+ Optional<DataModel::Nullable<Structs::PowerSavingsControlStruct::Type>> powerSavingsControl;
+ Optional<DataModel::Nullable<Structs::HeatingSourceControlStruct::Type>> heatingSourceControl;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LoadControlEventStatusChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DemandResponseLoadControl::Id; }
+
+ chip::ByteSpan eventID;
+ DataModel::Nullable<uint8_t> transitionIndex;
+ LoadControlEventStatusEnum status = static_cast<LoadControlEventStatusEnum>(0);
+ CriticalityLevelEnum criticality = static_cast<CriticalityLevelEnum>(0);
+ chip::BitMask<EventControlBitmap> control = static_cast<chip::BitMask<EventControlBitmap>>(0);
+ Optional<DataModel::Nullable<Structs::TemperatureControlStruct::DecodableType>> temperatureControl;
+ Optional<DataModel::Nullable<Structs::AverageLoadControlStruct::DecodableType>> averageLoadControl;
+ Optional<DataModel::Nullable<Structs::DutyCycleControlStruct::DecodableType>> dutyCycleControl;
+ Optional<DataModel::Nullable<Structs::PowerSavingsControlStruct::DecodableType>> powerSavingsControl;
+ Optional<DataModel::Nullable<Structs::HeatingSourceControlStruct::DecodableType>> heatingSourceControl;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LoadControlEventStatusChange
+} // namespace Events
+} // namespace DemandResponseLoadControl
+namespace Messages {
+namespace Structs {
+namespace MessageResponseOptionStruct {
+enum class Fields : uint8_t
+{
+ kMessageResponseID = 0,
+ kLabel = 1,
+};
+
+struct Type
+{
+public:
+ Optional<uint32_t> messageResponseID;
+ Optional<chip::CharSpan> label;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MessageResponseOptionStruct
+namespace MessageStruct {
+enum class Fields : uint8_t
+{
+ kMessageID = 0,
+ kPriority = 1,
+ kMessageControl = 2,
+ kStartTime = 3,
+ kDuration = 4,
+ kMessageText = 5,
+ kResponses = 6,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan messageID;
+ MessagePriorityEnum priority = static_cast<MessagePriorityEnum>(0);
+ chip::BitMask<MessageControlBitmap> messageControl = static_cast<chip::BitMask<MessageControlBitmap>>(0);
+ DataModel::Nullable<uint32_t> startTime;
+ DataModel::Nullable<uint64_t> duration;
+ chip::CharSpan messageText;
+ Optional<DataModel::List<const Structs::MessageResponseOptionStruct::Type>> responses;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::ByteSpan messageID;
+ MessagePriorityEnum priority = static_cast<MessagePriorityEnum>(0);
+ chip::BitMask<MessageControlBitmap> messageControl = static_cast<chip::BitMask<MessageControlBitmap>>(0);
+ DataModel::Nullable<uint32_t> startTime;
+ DataModel::Nullable<uint64_t> duration;
+ chip::CharSpan messageText;
+ Optional<DataModel::DecodableList<Structs::MessageResponseOptionStruct::DecodableType>> responses;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace MessageStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace PresentMessagesRequest {
+struct Type;
+struct DecodableType;
+} // namespace PresentMessagesRequest
+
+namespace CancelMessagesRequest {
+struct Type;
+struct DecodableType;
+} // namespace CancelMessagesRequest
+
+} // namespace Commands
+
+namespace Commands {
+namespace PresentMessagesRequest {
+enum class Fields : uint8_t
+{
+ kMessageID = 0,
+ kPriority = 1,
+ kMessageControl = 2,
+ kStartTime = 3,
+ kDuration = 4,
+ kMessageText = 5,
+ kResponses = 6,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PresentMessagesRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ chip::ByteSpan messageID;
+ MessagePriorityEnum priority = static_cast<MessagePriorityEnum>(0);
+ chip::BitMask<MessageControlBitmap> messageControl = static_cast<chip::BitMask<MessageControlBitmap>>(0);
+ DataModel::Nullable<uint32_t> startTime;
+ DataModel::Nullable<uint64_t> duration;
+ chip::CharSpan messageText;
+ Optional<DataModel::List<const Structs::MessageResponseOptionStruct::Type>> responses;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PresentMessagesRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ chip::ByteSpan messageID;
+ MessagePriorityEnum priority = static_cast<MessagePriorityEnum>(0);
+ chip::BitMask<MessageControlBitmap> messageControl = static_cast<chip::BitMask<MessageControlBitmap>>(0);
+ DataModel::Nullable<uint32_t> startTime;
+ DataModel::Nullable<uint64_t> duration;
+ chip::CharSpan messageText;
+ Optional<DataModel::DecodableList<Structs::MessageResponseOptionStruct::DecodableType>> responses;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PresentMessagesRequest
+namespace CancelMessagesRequest {
+enum class Fields : uint8_t
+{
+ kMessageIDs = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CancelMessagesRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ DataModel::List<const chip::ByteSpan> messageIDs;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CancelMessagesRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ DataModel::DecodableList<chip::ByteSpan> messageIDs;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelMessagesRequest
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Messages {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Messages::Structs::MessageStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::Messages::Structs::MessageStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Messages::Structs::MessageStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Messages::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Messages
+namespace ActiveMessageIDs {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveMessageIDs::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveMessageIDs
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Messages::TypeInfo::DecodableType messages;
+ Attributes::ActiveMessageIDs::TypeInfo::DecodableType activeMessageIDs;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace MessageQueued {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kMessageID = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MessageQueued::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::ByteSpan messageID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MessageQueued::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ chip::ByteSpan messageID;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MessageQueued
+namespace MessagePresented {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kMessageID = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MessagePresented::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::ByteSpan messageID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MessagePresented::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ chip::ByteSpan messageID;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MessagePresented
+namespace MessageComplete {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kMessageID = 0,
+ kResponseID = 1,
+ kReply = 2,
+ kFutureMessagesPreference = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MessageComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::ByteSpan messageID;
+ Optional<DataModel::Nullable<uint32_t>> responseID;
+ Optional<DataModel::Nullable<chip::CharSpan>> reply;
+ DataModel::Nullable<FutureMessagePreferenceEnum> futureMessagesPreference;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MessageComplete::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Messages::Id; }
+
+ chip::ByteSpan messageID;
+ Optional<DataModel::Nullable<uint32_t>> responseID;
+ Optional<DataModel::Nullable<chip::CharSpan>> reply;
+ DataModel::Nullable<FutureMessagePreferenceEnum> futureMessagesPreference;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MessageComplete
+} // namespace Events
+} // namespace Messages
+namespace DeviceEnergyManagement {
+namespace Structs {
+namespace CostStruct {
+enum class Fields : uint8_t
+{
+ kCostType = 0,
+ kValue = 1,
+ kDecimalPoints = 2,
+ kCurrency = 3,
+};
+
+struct Type
+{
+public:
+ CostTypeEnum costType = static_cast<CostTypeEnum>(0);
+ int32_t value = static_cast<int32_t>(0);
+ uint8_t decimalPoints = static_cast<uint8_t>(0);
+ Optional<uint16_t> currency;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace CostStruct
+namespace PowerAdjustStruct {
+enum class Fields : uint8_t
+{
+ kMinPower = 0,
+ kMaxPower = 1,
+ kMinDuration = 2,
+ kMaxDuration = 3,
+};
+
+struct Type
+{
+public:
+ int64_t minPower = static_cast<int64_t>(0);
+ int64_t maxPower = static_cast<int64_t>(0);
+ uint32_t minDuration = static_cast<uint32_t>(0);
+ uint32_t maxDuration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace PowerAdjustStruct
+namespace PowerAdjustCapabilityStruct {
+enum class Fields : uint8_t
+{
+ kPowerAdjustCapability = 0,
+ kCause = 1,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<DataModel::List<const Structs::PowerAdjustStruct::Type>> powerAdjustCapability;
+ PowerAdjustReasonEnum cause = static_cast<PowerAdjustReasonEnum>(0);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::Nullable<DataModel::DecodableList<Structs::PowerAdjustStruct::DecodableType>> powerAdjustCapability;
+ PowerAdjustReasonEnum cause = static_cast<PowerAdjustReasonEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace PowerAdjustCapabilityStruct
+namespace SlotStruct {
+enum class Fields : uint8_t
+{
+ kMinDuration = 0,
+ kMaxDuration = 1,
+ kDefaultDuration = 2,
+ kElapsedSlotTime = 3,
+ kRemainingSlotTime = 4,
+ kSlotIsPausable = 5,
+ kMinPauseDuration = 6,
+ kMaxPauseDuration = 7,
+ kManufacturerESAState = 8,
+ kNominalPower = 9,
+ kMinPower = 10,
+ kMaxPower = 11,
+ kNominalEnergy = 12,
+ kCosts = 13,
+ kMinPowerAdjustment = 14,
+ kMaxPowerAdjustment = 15,
+ kMinDurationAdjustment = 16,
+ kMaxDurationAdjustment = 17,
+};
+
+struct Type
+{
+public:
+ uint32_t minDuration = static_cast<uint32_t>(0);
+ uint32_t maxDuration = static_cast<uint32_t>(0);
+ uint32_t defaultDuration = static_cast<uint32_t>(0);
+ uint32_t elapsedSlotTime = static_cast<uint32_t>(0);
+ uint32_t remainingSlotTime = static_cast<uint32_t>(0);
+ Optional<bool> slotIsPausable;
+ Optional<uint32_t> minPauseDuration;
+ Optional<uint32_t> maxPauseDuration;
+ Optional<uint16_t> manufacturerESAState;
+ Optional<int64_t> nominalPower;
+ Optional<int64_t> minPower;
+ Optional<int64_t> maxPower;
+ Optional<int64_t> nominalEnergy;
+ Optional<DataModel::List<const Structs::CostStruct::Type>> costs;
+ Optional<int64_t> minPowerAdjustment;
+ Optional<int64_t> maxPowerAdjustment;
+ Optional<uint32_t> minDurationAdjustment;
+ Optional<uint32_t> maxDurationAdjustment;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ uint32_t minDuration = static_cast<uint32_t>(0);
+ uint32_t maxDuration = static_cast<uint32_t>(0);
+ uint32_t defaultDuration = static_cast<uint32_t>(0);
+ uint32_t elapsedSlotTime = static_cast<uint32_t>(0);
+ uint32_t remainingSlotTime = static_cast<uint32_t>(0);
+ Optional<bool> slotIsPausable;
+ Optional<uint32_t> minPauseDuration;
+ Optional<uint32_t> maxPauseDuration;
+ Optional<uint16_t> manufacturerESAState;
+ Optional<int64_t> nominalPower;
+ Optional<int64_t> minPower;
+ Optional<int64_t> maxPower;
+ Optional<int64_t> nominalEnergy;
+ Optional<DataModel::DecodableList<Structs::CostStruct::DecodableType>> costs;
+ Optional<int64_t> minPowerAdjustment;
+ Optional<int64_t> maxPowerAdjustment;
+ Optional<uint32_t> minDurationAdjustment;
+ Optional<uint32_t> maxDurationAdjustment;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace SlotStruct
+namespace ForecastStruct {
+enum class Fields : uint8_t
+{
+ kForecastID = 0,
+ kActiveSlotNumber = 1,
+ kStartTime = 2,
+ kEndTime = 3,
+ kEarliestStartTime = 4,
+ kLatestEndTime = 5,
+ kIsPausable = 6,
+ kSlots = 7,
+ kForecastUpdateReason = 8,
+};
+
+struct Type
+{
+public:
+ uint32_t forecastID = static_cast<uint32_t>(0);
+ DataModel::Nullable<uint16_t> activeSlotNumber;
+ uint32_t startTime = static_cast<uint32_t>(0);
+ uint32_t endTime = static_cast<uint32_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> earliestStartTime;
+ Optional<uint32_t> latestEndTime;
+ bool isPausable = static_cast<bool>(0);
+ DataModel::List<const Structs::SlotStruct::Type> slots;
+ ForecastUpdateReasonEnum forecastUpdateReason = static_cast<ForecastUpdateReasonEnum>(0);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ uint32_t forecastID = static_cast<uint32_t>(0);
+ DataModel::Nullable<uint16_t> activeSlotNumber;
+ uint32_t startTime = static_cast<uint32_t>(0);
+ uint32_t endTime = static_cast<uint32_t>(0);
+ Optional<DataModel::Nullable<uint32_t>> earliestStartTime;
+ Optional<uint32_t> latestEndTime;
+ bool isPausable = static_cast<bool>(0);
+ DataModel::DecodableList<Structs::SlotStruct::DecodableType> slots;
+ ForecastUpdateReasonEnum forecastUpdateReason = static_cast<ForecastUpdateReasonEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ForecastStruct
+namespace ConstraintsStruct {
+enum class Fields : uint8_t
+{
+ kStartTime = 0,
+ kDuration = 1,
+ kNominalPower = 2,
+ kMaximumEnergy = 3,
+ kLoadControl = 4,
+};
+
+struct Type
+{
+public:
+ uint32_t startTime = static_cast<uint32_t>(0);
+ uint32_t duration = static_cast<uint32_t>(0);
+ Optional<int64_t> nominalPower;
+ Optional<int64_t> maximumEnergy;
+ Optional<int8_t> loadControl;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ConstraintsStruct
+namespace SlotAdjustmentStruct {
+enum class Fields : uint8_t
+{
+ kSlotIndex = 0,
+ kNominalPower = 1,
+ kDuration = 2,
+};
+
+struct Type
+{
+public:
+ uint8_t slotIndex = static_cast<uint8_t>(0);
+ Optional<int64_t> nominalPower;
+ uint32_t duration = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SlotAdjustmentStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace PowerAdjustRequest {
+struct Type;
+struct DecodableType;
+} // namespace PowerAdjustRequest
+
+namespace CancelPowerAdjustRequest {
+struct Type;
+struct DecodableType;
+} // namespace CancelPowerAdjustRequest
+
+namespace StartTimeAdjustRequest {
+struct Type;
+struct DecodableType;
+} // namespace StartTimeAdjustRequest
+
+namespace PauseRequest {
+struct Type;
+struct DecodableType;
+} // namespace PauseRequest
+
+namespace ResumeRequest {
+struct Type;
+struct DecodableType;
+} // namespace ResumeRequest
+
+namespace ModifyForecastRequest {
+struct Type;
+struct DecodableType;
+} // namespace ModifyForecastRequest
+
+namespace RequestConstraintBasedForecast {
+struct Type;
+struct DecodableType;
+} // namespace RequestConstraintBasedForecast
+
+namespace CancelRequest {
+struct Type;
+struct DecodableType;
+} // namespace CancelRequest
+
+} // namespace Commands
+
+namespace Commands {
+namespace PowerAdjustRequest {
+enum class Fields : uint8_t
+{
+ kPower = 0,
+ kDuration = 1,
+ kCause = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PowerAdjustRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ int64_t power = static_cast<int64_t>(0);
+ uint32_t duration = static_cast<uint32_t>(0);
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PowerAdjustRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ int64_t power = static_cast<int64_t>(0);
+ uint32_t duration = static_cast<uint32_t>(0);
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PowerAdjustRequest
+namespace CancelPowerAdjustRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CancelPowerAdjustRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CancelPowerAdjustRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelPowerAdjustRequest
+namespace StartTimeAdjustRequest {
+enum class Fields : uint8_t
+{
+ kRequestedStartTime = 0,
+ kCause = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StartTimeAdjustRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ uint32_t requestedStartTime = static_cast<uint32_t>(0);
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StartTimeAdjustRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ uint32_t requestedStartTime = static_cast<uint32_t>(0);
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartTimeAdjustRequest
+namespace PauseRequest {
+enum class Fields : uint8_t
+{
+ kDuration = 0,
+ kCause = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PauseRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ uint32_t duration = static_cast<uint32_t>(0);
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PauseRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ uint32_t duration = static_cast<uint32_t>(0);
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PauseRequest
+namespace ResumeRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResumeRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResumeRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResumeRequest
+namespace ModifyForecastRequest {
+enum class Fields : uint8_t
+{
+ kForecastID = 0,
+ kSlotAdjustments = 1,
+ kCause = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ModifyForecastRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ uint32_t forecastID = static_cast<uint32_t>(0);
+ DataModel::List<const Structs::SlotAdjustmentStruct::Type> slotAdjustments;
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ModifyForecastRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ uint32_t forecastID = static_cast<uint32_t>(0);
+ DataModel::DecodableList<Structs::SlotAdjustmentStruct::DecodableType> slotAdjustments;
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ModifyForecastRequest
+namespace RequestConstraintBasedForecast {
+enum class Fields : uint8_t
+{
+ kConstraints = 0,
+ kCause = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RequestConstraintBasedForecast::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ DataModel::List<const Structs::ConstraintsStruct::Type> constraints;
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RequestConstraintBasedForecast::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ DataModel::DecodableList<Structs::ConstraintsStruct::DecodableType> constraints;
+ AdjustmentCauseEnum cause = static_cast<AdjustmentCauseEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RequestConstraintBasedForecast
+namespace CancelRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CancelRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CancelRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelRequest
+} // namespace Commands
+
+namespace Attributes {
+
+namespace ESAType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::DeviceEnergyManagement::ESATypeEnum;
+ using DecodableType = chip::app::Clusters::DeviceEnergyManagement::ESATypeEnum;
+ using DecodableArgType = chip::app::Clusters::DeviceEnergyManagement::ESATypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ESAType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ESAType
+namespace ESACanGenerate {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ESACanGenerate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ESACanGenerate
+namespace ESAState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::DeviceEnergyManagement::ESAStateEnum;
+ using DecodableType = chip::app::Clusters::DeviceEnergyManagement::ESAStateEnum;
+ using DecodableArgType = chip::app::Clusters::DeviceEnergyManagement::ESAStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ESAState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ESAState
+namespace AbsMinPower {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AbsMinPower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AbsMinPower
+namespace AbsMaxPower {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AbsMaxPower::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AbsMaxPower
+namespace PowerAdjustmentCapability {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::Nullable<chip::app::Clusters::DeviceEnergyManagement::Structs::PowerAdjustCapabilityStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::Clusters::DeviceEnergyManagement::Structs::PowerAdjustCapabilityStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::DeviceEnergyManagement::Structs::PowerAdjustCapabilityStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PowerAdjustmentCapability::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PowerAdjustmentCapability
+namespace Forecast {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::DeviceEnergyManagement::Structs::ForecastStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::Nullable<chip::app::Clusters::DeviceEnergyManagement::Structs::ForecastStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::DeviceEnergyManagement::Structs::ForecastStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Forecast::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Forecast
+namespace OptOutState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::DeviceEnergyManagement::OptOutStateEnum;
+ using DecodableType = chip::app::Clusters::DeviceEnergyManagement::OptOutStateEnum;
+ using DecodableArgType = chip::app::Clusters::DeviceEnergyManagement::OptOutStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OptOutState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OptOutState
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::ESAType::TypeInfo::DecodableType ESAType =
+ static_cast<chip::app::Clusters::DeviceEnergyManagement::ESATypeEnum>(0);
+ Attributes::ESACanGenerate::TypeInfo::DecodableType ESACanGenerate = static_cast<bool>(0);
+ Attributes::ESAState::TypeInfo::DecodableType ESAState =
+ static_cast<chip::app::Clusters::DeviceEnergyManagement::ESAStateEnum>(0);
+ Attributes::AbsMinPower::TypeInfo::DecodableType absMinPower = static_cast<int64_t>(0);
+ Attributes::AbsMaxPower::TypeInfo::DecodableType absMaxPower = static_cast<int64_t>(0);
+ Attributes::PowerAdjustmentCapability::TypeInfo::DecodableType powerAdjustmentCapability;
+ Attributes::Forecast::TypeInfo::DecodableType forecast;
+ Attributes::OptOutState::TypeInfo::DecodableType optOutState =
+ static_cast<chip::app::Clusters::DeviceEnergyManagement::OptOutStateEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace PowerAdjustStart {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PowerAdjustStart::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PowerAdjustStart::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PowerAdjustStart
+namespace PowerAdjustEnd {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCause = 0,
+ kDuration = 1,
+ kEnergyUse = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PowerAdjustEnd::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CauseEnum cause = static_cast<CauseEnum>(0);
+ uint32_t duration = static_cast<uint32_t>(0);
+ int64_t energyUse = static_cast<int64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PowerAdjustEnd::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CauseEnum cause = static_cast<CauseEnum>(0);
+ uint32_t duration = static_cast<uint32_t>(0);
+ int64_t energyUse = static_cast<int64_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PowerAdjustEnd
+namespace Paused {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Paused::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Paused::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Paused
+namespace Resumed {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCause = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Resumed::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CauseEnum cause = static_cast<CauseEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Resumed::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagement::Id; }
+
+ CauseEnum cause = static_cast<CauseEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Resumed
+} // namespace Events
+} // namespace DeviceEnergyManagement
+namespace EnergyEvse {
+namespace Structs {
+namespace ChargingTargetStruct {
+enum class Fields : uint8_t
+{
+ kTargetTimeMinutesPastMidnight = 0,
+ kTargetSoC = 1,
+ kAddedEnergy = 2,
+};
+
+struct Type
+{
+public:
+ uint16_t targetTimeMinutesPastMidnight = static_cast<uint16_t>(0);
+ Optional<chip::Percent> targetSoC;
+ Optional<int64_t> addedEnergy;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ChargingTargetStruct
+namespace ChargingTargetScheduleStruct {
+enum class Fields : uint8_t
+{
+ kDayOfWeekForSequence = 0,
+ kChargingTargets = 1,
+};
+
+struct Type
+{
+public:
+ chip::BitMask<TargetDayOfWeekBitmap> dayOfWeekForSequence = static_cast<chip::BitMask<TargetDayOfWeekBitmap>>(0);
+ DataModel::List<const Structs::ChargingTargetStruct::Type> chargingTargets;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::BitMask<TargetDayOfWeekBitmap> dayOfWeekForSequence = static_cast<chip::BitMask<TargetDayOfWeekBitmap>>(0);
+ DataModel::DecodableList<Structs::ChargingTargetStruct::DecodableType> chargingTargets;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ChargingTargetScheduleStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace GetTargetsResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetTargetsResponse
+
+namespace Disable {
+struct Type;
+struct DecodableType;
+} // namespace Disable
+
+namespace EnableCharging {
+struct Type;
+struct DecodableType;
+} // namespace EnableCharging
+
+namespace EnableDischarging {
+struct Type;
+struct DecodableType;
+} // namespace EnableDischarging
+
+namespace StartDiagnostics {
+struct Type;
+struct DecodableType;
+} // namespace StartDiagnostics
+
+namespace SetTargets {
+struct Type;
+struct DecodableType;
+} // namespace SetTargets
+
+namespace GetTargets {
+struct Type;
+struct DecodableType;
+} // namespace GetTargets
+
+namespace ClearTargets {
+struct Type;
+struct DecodableType;
+} // namespace ClearTargets
+
+} // namespace Commands
+
+namespace Commands {
+namespace GetTargetsResponse {
+enum class Fields : uint8_t
+{
+ kChargingTargetSchedules = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetTargetsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::List<const Structs::ChargingTargetScheduleStruct::Type> chargingTargetSchedules;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetTargetsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::DecodableList<Structs::ChargingTargetScheduleStruct::DecodableType> chargingTargetSchedules;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetTargetsResponse
+namespace Disable {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Disable::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Disable::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Disable
+namespace EnableCharging {
+enum class Fields : uint8_t
+{
+ kChargingEnabledUntil = 0,
+ kMinimumChargeCurrent = 1,
+ kMaximumChargeCurrent = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnableCharging::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::Nullable<uint32_t> chargingEnabledUntil;
+ int64_t minimumChargeCurrent = static_cast<int64_t>(0);
+ int64_t maximumChargeCurrent = static_cast<int64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnableCharging::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::Nullable<uint32_t> chargingEnabledUntil;
+ int64_t minimumChargeCurrent = static_cast<int64_t>(0);
+ int64_t maximumChargeCurrent = static_cast<int64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableCharging
+namespace EnableDischarging {
+enum class Fields : uint8_t
+{
+ kDischargingEnabledUntil = 0,
+ kMaximumDischargeCurrent = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnableDischarging::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::Nullable<uint32_t> dischargingEnabledUntil;
+ int64_t maximumDischargeCurrent = static_cast<int64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnableDischarging::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::Nullable<uint32_t> dischargingEnabledUntil;
+ int64_t maximumDischargeCurrent = static_cast<int64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnableDischarging
+namespace StartDiagnostics {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StartDiagnostics::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StartDiagnostics::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartDiagnostics
+namespace SetTargets {
+enum class Fields : uint8_t
+{
+ kChargingTargetSchedules = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetTargets::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::List<const Structs::ChargingTargetScheduleStruct::Type> chargingTargetSchedules;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetTargets::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::DecodableList<Structs::ChargingTargetScheduleStruct::DecodableType> chargingTargetSchedules;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetTargets
+namespace GetTargets {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetTargets::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::EnergyEvse::Commands::GetTargetsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetTargets::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetTargets
+namespace ClearTargets {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearTargets::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearTargets::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearTargets
+} // namespace Commands
+
+namespace Attributes {
+
+namespace State {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::EnergyEvse::StateEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::EnergyEvse::StateEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::EnergyEvse::StateEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace State
+namespace SupplyState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::EnergyEvse::SupplyStateEnum;
+ using DecodableType = chip::app::Clusters::EnergyEvse::SupplyStateEnum;
+ using DecodableArgType = chip::app::Clusters::EnergyEvse::SupplyStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupplyState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupplyState
+namespace FaultState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::EnergyEvse::FaultStateEnum;
+ using DecodableType = chip::app::Clusters::EnergyEvse::FaultStateEnum;
+ using DecodableArgType = chip::app::Clusters::EnergyEvse::FaultStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FaultState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FaultState
+namespace ChargingEnabledUntil {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChargingEnabledUntil::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ChargingEnabledUntil
+namespace DischargingEnabledUntil {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DischargingEnabledUntil::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DischargingEnabledUntil
+namespace CircuitCapacity {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CircuitCapacity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CircuitCapacity
+namespace MinimumChargeCurrent {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinimumChargeCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinimumChargeCurrent
+namespace MaximumChargeCurrent {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaximumChargeCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaximumChargeCurrent
+namespace MaximumDischargeCurrent {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaximumDischargeCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaximumDischargeCurrent
+namespace UserMaximumChargeCurrent {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UserMaximumChargeCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UserMaximumChargeCurrent
+namespace RandomizationDelayWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RandomizationDelayWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RandomizationDelayWindow
+namespace NextChargeStartTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NextChargeStartTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NextChargeStartTime
+namespace NextChargeTargetTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NextChargeTargetTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NextChargeTargetTime
+namespace NextChargeRequiredEnergy {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NextChargeRequiredEnergy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NextChargeRequiredEnergy
+namespace NextChargeTargetSoC {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NextChargeTargetSoC::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NextChargeTargetSoC
+namespace ApproximateEVEfficiency {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ApproximateEVEfficiency::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ApproximateEVEfficiency
+namespace StateOfCharge {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StateOfCharge::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StateOfCharge
+namespace BatteryCapacity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BatteryCapacity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BatteryCapacity
+namespace VehicleID {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VehicleID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace VehicleID
+namespace SessionID {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SessionID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SessionID
+namespace SessionDuration {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SessionDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SessionDuration
+namespace SessionEnergyCharged {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SessionEnergyCharged::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SessionEnergyCharged
+namespace SessionEnergyDischarged {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SessionEnergyDischarged::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SessionEnergyDischarged
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::State::TypeInfo::DecodableType state;
+ Attributes::SupplyState::TypeInfo::DecodableType supplyState =
+ static_cast<chip::app::Clusters::EnergyEvse::SupplyStateEnum>(0);
+ Attributes::FaultState::TypeInfo::DecodableType faultState =
+ static_cast<chip::app::Clusters::EnergyEvse::FaultStateEnum>(0);
+ Attributes::ChargingEnabledUntil::TypeInfo::DecodableType chargingEnabledUntil;
+ Attributes::DischargingEnabledUntil::TypeInfo::DecodableType dischargingEnabledUntil;
+ Attributes::CircuitCapacity::TypeInfo::DecodableType circuitCapacity = static_cast<int64_t>(0);
+ Attributes::MinimumChargeCurrent::TypeInfo::DecodableType minimumChargeCurrent = static_cast<int64_t>(0);
+ Attributes::MaximumChargeCurrent::TypeInfo::DecodableType maximumChargeCurrent = static_cast<int64_t>(0);
+ Attributes::MaximumDischargeCurrent::TypeInfo::DecodableType maximumDischargeCurrent = static_cast<int64_t>(0);
+ Attributes::UserMaximumChargeCurrent::TypeInfo::DecodableType userMaximumChargeCurrent = static_cast<int64_t>(0);
+ Attributes::RandomizationDelayWindow::TypeInfo::DecodableType randomizationDelayWindow = static_cast<uint32_t>(0);
+ Attributes::NextChargeStartTime::TypeInfo::DecodableType nextChargeStartTime;
+ Attributes::NextChargeTargetTime::TypeInfo::DecodableType nextChargeTargetTime;
+ Attributes::NextChargeRequiredEnergy::TypeInfo::DecodableType nextChargeRequiredEnergy;
+ Attributes::NextChargeTargetSoC::TypeInfo::DecodableType nextChargeTargetSoC;
+ Attributes::ApproximateEVEfficiency::TypeInfo::DecodableType approximateEVEfficiency;
+ Attributes::StateOfCharge::TypeInfo::DecodableType stateOfCharge;
+ Attributes::BatteryCapacity::TypeInfo::DecodableType batteryCapacity;
+ Attributes::VehicleID::TypeInfo::DecodableType vehicleID;
+ Attributes::SessionID::TypeInfo::DecodableType sessionID;
+ Attributes::SessionDuration::TypeInfo::DecodableType sessionDuration;
+ Attributes::SessionEnergyCharged::TypeInfo::DecodableType sessionEnergyCharged;
+ Attributes::SessionEnergyDischarged::TypeInfo::DecodableType sessionEnergyDischarged;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace EVConnected {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSessionID = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EVConnected::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EVConnected::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace EVConnected
+namespace EVNotDetected {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSessionID = 0,
+ kState = 1,
+ kSessionDuration = 2,
+ kSessionEnergyCharged = 3,
+ kSessionEnergyDischarged = 4,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EVNotDetected::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+ StateEnum state = static_cast<StateEnum>(0);
+ uint32_t sessionDuration = static_cast<uint32_t>(0);
+ int64_t sessionEnergyCharged = static_cast<int64_t>(0);
+ Optional<int64_t> sessionEnergyDischarged;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EVNotDetected::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+ StateEnum state = static_cast<StateEnum>(0);
+ uint32_t sessionDuration = static_cast<uint32_t>(0);
+ int64_t sessionEnergyCharged = static_cast<int64_t>(0);
+ Optional<int64_t> sessionEnergyDischarged;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace EVNotDetected
+namespace EnergyTransferStarted {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSessionID = 0,
+ kState = 1,
+ kMaximumCurrent = 2,
+ kMaximumDischargeCurrent = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EnergyTransferStarted::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+ StateEnum state = static_cast<StateEnum>(0);
+ int64_t maximumCurrent = static_cast<int64_t>(0);
+ Optional<int64_t> maximumDischargeCurrent;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EnergyTransferStarted::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+ StateEnum state = static_cast<StateEnum>(0);
+ int64_t maximumCurrent = static_cast<int64_t>(0);
+ Optional<int64_t> maximumDischargeCurrent;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace EnergyTransferStarted
+namespace EnergyTransferStopped {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSessionID = 0,
+ kState = 1,
+ kReason = 2,
+ kEnergyTransferred = 4,
+ kEnergyDischarged = 5,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EnergyTransferStopped::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+ StateEnum state = static_cast<StateEnum>(0);
+ EnergyTransferStoppedReasonEnum reason = static_cast<EnergyTransferStoppedReasonEnum>(0);
+ int64_t energyTransferred = static_cast<int64_t>(0);
+ Optional<int64_t> energyDischarged;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::EnergyTransferStopped::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ uint32_t sessionID = static_cast<uint32_t>(0);
+ StateEnum state = static_cast<StateEnum>(0);
+ EnergyTransferStoppedReasonEnum reason = static_cast<EnergyTransferStoppedReasonEnum>(0);
+ int64_t energyTransferred = static_cast<int64_t>(0);
+ Optional<int64_t> energyDischarged;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace EnergyTransferStopped
+namespace Fault {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kSessionID = 0,
+ kState = 1,
+ kFaultStatePreviousState = 2,
+ kFaultStateCurrentState = 4,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Fault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::Nullable<uint32_t> sessionID;
+ StateEnum state = static_cast<StateEnum>(0);
+ FaultStateEnum faultStatePreviousState = static_cast<FaultStateEnum>(0);
+ FaultStateEnum faultStateCurrentState = static_cast<FaultStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Fault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ DataModel::Nullable<uint32_t> sessionID;
+ StateEnum state = static_cast<StateEnum>(0);
+ FaultStateEnum faultStatePreviousState = static_cast<FaultStateEnum>(0);
+ FaultStateEnum faultStateCurrentState = static_cast<FaultStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Fault
+namespace Rfid {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kUid = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Rfid::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::ByteSpan uid;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Rfid::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvse::Id; }
+
+ chip::ByteSpan uid;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Rfid
+} // namespace Events
+} // namespace EnergyEvse
+namespace EnergyPreference {
+namespace Structs {
+namespace BalanceStruct {
+enum class Fields : uint8_t
+{
+ kStep = 0,
+ kLabel = 1,
+};
+
+struct Type
+{
+public:
+ chip::Percent step = static_cast<chip::Percent>(0);
+ Optional<chip::CharSpan> label;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace BalanceStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace EnergyBalances {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnergyBalances::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnergyBalances
+namespace CurrentEnergyBalance {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentEnergyBalance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentEnergyBalance
+namespace EnergyPriorities {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::EnergyPreference::EnergyPriorityEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyPreference::EnergyPriorityEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyPreference::EnergyPriorityEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnergyPriorities::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnergyPriorities
+namespace LowPowerModeSensitivities {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LowPowerModeSensitivities::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LowPowerModeSensitivities
+namespace CurrentLowPowerModeSensitivity {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLowPowerModeSensitivity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentLowPowerModeSensitivity
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::EnergyBalances::TypeInfo::DecodableType energyBalances;
+ Attributes::CurrentEnergyBalance::TypeInfo::DecodableType currentEnergyBalance = static_cast<uint8_t>(0);
+ Attributes::EnergyPriorities::TypeInfo::DecodableType energyPriorities;
+ Attributes::LowPowerModeSensitivities::TypeInfo::DecodableType lowPowerModeSensitivities;
+ Attributes::CurrentLowPowerModeSensitivity::TypeInfo::DecodableType currentLowPowerModeSensitivity =
+ static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace EnergyPreference
+namespace PowerTopology {
+
+namespace Attributes {
+
+namespace AvailableEndpoints {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::EndpointId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::EndpointId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AvailableEndpoints::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AvailableEndpoints
+namespace ActiveEndpoints {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::EndpointId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::EndpointId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveEndpoints::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveEndpoints
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::PowerTopology::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::AvailableEndpoints::TypeInfo::DecodableType availableEndpoints;
+ Attributes::ActiveEndpoints::TypeInfo::DecodableType activeEndpoints;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace PowerTopology
+namespace EnergyEvseMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::EnergyEvseMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::EnergyEvseMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyEvseMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::EnergyEvseMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::EnergyEvseMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace EnergyEvseMode
+namespace WaterHeaterMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::WaterHeaterMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::WaterHeaterMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::WaterHeaterMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::WaterHeaterMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WaterHeaterMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace WaterHeaterMode
+namespace DeviceEnergyManagementMode {
+namespace Structs {
+namespace ModeTagStruct = Clusters::detail::Structs::ModeTagStruct;
+namespace ModeOptionStruct = Clusters::detail::Structs::ModeOptionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeToMode {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeToMode {
+enum class Fields : uint8_t
+{
+ kNewMode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DeviceEnergyManagementMode::Commands::ChangeToModeResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+
+ uint8_t newMode = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToMode
+namespace ChangeToModeResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeToModeResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+
+ uint8_t status = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeToModeResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedModes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::DeviceEnergyManagementMode::Structs::ModeOptionStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DeviceEnergyManagementMode::Structs::ModeOptionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::DeviceEnergyManagementMode::Structs::ModeOptionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedModes
+namespace CurrentMode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DeviceEnergyManagementMode::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedModes::TypeInfo::DecodableType supportedModes;
+ Attributes::CurrentMode::TypeInfo::DecodableType currentMode = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace DeviceEnergyManagementMode
+namespace DoorLock {
+namespace Structs {
+namespace CredentialStruct {
+enum class Fields : uint8_t
+{
+ kCredentialType = 0,
+ kCredentialIndex = 1,
+};
+
+struct Type
+{
+public:
+ CredentialTypeEnum credentialType = static_cast<CredentialTypeEnum>(0);
+ uint16_t credentialIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace CredentialStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace LockDoor {
+struct Type;
+struct DecodableType;
+} // namespace LockDoor
+
+namespace UnlockDoor {
+struct Type;
+struct DecodableType;
+} // namespace UnlockDoor
+
+namespace UnlockWithTimeout {
+struct Type;
+struct DecodableType;
+} // namespace UnlockWithTimeout
+
+namespace SetWeekDaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace SetWeekDaySchedule
+
+namespace GetWeekDaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace GetWeekDaySchedule
+
+namespace GetWeekDayScheduleResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetWeekDayScheduleResponse
+
+namespace ClearWeekDaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace ClearWeekDaySchedule
+
+namespace SetYearDaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace SetYearDaySchedule
+
+namespace GetYearDaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace GetYearDaySchedule
+
+namespace GetYearDayScheduleResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetYearDayScheduleResponse
+
+namespace ClearYearDaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace ClearYearDaySchedule
+
+namespace SetHolidaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace SetHolidaySchedule
+
+namespace GetHolidaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace GetHolidaySchedule
+
+namespace GetHolidayScheduleResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetHolidayScheduleResponse
+
+namespace ClearHolidaySchedule {
+struct Type;
+struct DecodableType;
+} // namespace ClearHolidaySchedule
+
+namespace SetUser {
+struct Type;
+struct DecodableType;
+} // namespace SetUser
+
+namespace GetUser {
+struct Type;
+struct DecodableType;
+} // namespace GetUser
+
+namespace GetUserResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetUserResponse
+
+namespace ClearUser {
+struct Type;
+struct DecodableType;
+} // namespace ClearUser
+
+namespace SetCredential {
+struct Type;
+struct DecodableType;
+} // namespace SetCredential
+
+namespace SetCredentialResponse {
+struct Type;
+struct DecodableType;
+} // namespace SetCredentialResponse
+
+namespace GetCredentialStatus {
+struct Type;
+struct DecodableType;
+} // namespace GetCredentialStatus
+
+namespace GetCredentialStatusResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetCredentialStatusResponse
+
+namespace ClearCredential {
+struct Type;
+struct DecodableType;
+} // namespace ClearCredential
+
+namespace UnboltDoor {
+struct Type;
+struct DecodableType;
+} // namespace UnboltDoor
+
+namespace SetAliroReaderConfig {
+struct Type;
+struct DecodableType;
+} // namespace SetAliroReaderConfig
+
+namespace ClearAliroReaderConfig {
+struct Type;
+struct DecodableType;
+} // namespace ClearAliroReaderConfig
+
+} // namespace Commands
+
+namespace Commands {
+namespace LockDoor {
+enum class Fields : uint8_t
+{
+ kPINCode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::LockDoor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Optional<chip::ByteSpan> PINCode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::LockDoor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Optional<chip::ByteSpan> PINCode;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LockDoor
+namespace UnlockDoor {
+enum class Fields : uint8_t
+{
+ kPINCode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UnlockDoor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Optional<chip::ByteSpan> PINCode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UnlockDoor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Optional<chip::ByteSpan> PINCode;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnlockDoor
+namespace UnlockWithTimeout {
+enum class Fields : uint8_t
+{
+ kTimeout = 0,
+ kPINCode = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UnlockWithTimeout::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t timeout = static_cast<uint16_t>(0);
+ Optional<chip::ByteSpan> PINCode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UnlockWithTimeout::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t timeout = static_cast<uint16_t>(0);
+ Optional<chip::ByteSpan> PINCode;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnlockWithTimeout
+namespace SetWeekDaySchedule {
+enum class Fields : uint8_t
+{
+ kWeekDayIndex = 0,
+ kUserIndex = 1,
+ kDaysMask = 2,
+ kStartHour = 3,
+ kStartMinute = 4,
+ kEndHour = 5,
+ kEndMinute = 6,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetWeekDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ chip::BitMask<DaysMaskMap> daysMask = static_cast<chip::BitMask<DaysMaskMap>>(0);
+ uint8_t startHour = static_cast<uint8_t>(0);
+ uint8_t startMinute = static_cast<uint8_t>(0);
+ uint8_t endHour = static_cast<uint8_t>(0);
+ uint8_t endMinute = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetWeekDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ chip::BitMask<DaysMaskMap> daysMask = static_cast<chip::BitMask<DaysMaskMap>>(0);
+ uint8_t startHour = static_cast<uint8_t>(0);
+ uint8_t startMinute = static_cast<uint8_t>(0);
+ uint8_t endHour = static_cast<uint8_t>(0);
+ uint8_t endMinute = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetWeekDaySchedule
+namespace GetWeekDaySchedule {
+enum class Fields : uint8_t
+{
+ kWeekDayIndex = 0,
+ kUserIndex = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetWeekDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DoorLock::Commands::GetWeekDayScheduleResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetWeekDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetWeekDaySchedule
+namespace GetWeekDayScheduleResponse {
+enum class Fields : uint8_t
+{
+ kWeekDayIndex = 0,
+ kUserIndex = 1,
+ kStatus = 2,
+ kDaysMask = 3,
+ kStartHour = 4,
+ kStartMinute = 5,
+ kEndHour = 6,
+ kEndMinute = 7,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetWeekDayScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DlStatus status = static_cast<DlStatus>(0);
+ Optional<chip::BitMask<DaysMaskMap>> daysMask;
+ Optional<uint8_t> startHour;
+ Optional<uint8_t> startMinute;
+ Optional<uint8_t> endHour;
+ Optional<uint8_t> endMinute;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetWeekDayScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DlStatus status = static_cast<DlStatus>(0);
+ Optional<chip::BitMask<DaysMaskMap>> daysMask;
+ Optional<uint8_t> startHour;
+ Optional<uint8_t> startMinute;
+ Optional<uint8_t> endHour;
+ Optional<uint8_t> endMinute;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetWeekDayScheduleResponse
+namespace ClearWeekDaySchedule {
+enum class Fields : uint8_t
+{
+ kWeekDayIndex = 0,
+ kUserIndex = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearWeekDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearWeekDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t weekDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearWeekDaySchedule
+namespace SetYearDaySchedule {
+enum class Fields : uint8_t
+{
+ kYearDayIndex = 0,
+ kUserIndex = 1,
+ kLocalStartTime = 2,
+ kLocalEndTime = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetYearDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ uint32_t localStartTime = static_cast<uint32_t>(0);
+ uint32_t localEndTime = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetYearDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ uint32_t localStartTime = static_cast<uint32_t>(0);
+ uint32_t localEndTime = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetYearDaySchedule
+namespace GetYearDaySchedule {
+enum class Fields : uint8_t
+{
+ kYearDayIndex = 0,
+ kUserIndex = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetYearDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DoorLock::Commands::GetYearDayScheduleResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetYearDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetYearDaySchedule
+namespace GetYearDayScheduleResponse {
+enum class Fields : uint8_t
+{
+ kYearDayIndex = 0,
+ kUserIndex = 1,
+ kStatus = 2,
+ kLocalStartTime = 3,
+ kLocalEndTime = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetYearDayScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DlStatus status = static_cast<DlStatus>(0);
+ Optional<uint32_t> localStartTime;
+ Optional<uint32_t> localEndTime;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetYearDayScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DlStatus status = static_cast<DlStatus>(0);
+ Optional<uint32_t> localStartTime;
+ Optional<uint32_t> localEndTime;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetYearDayScheduleResponse
+namespace ClearYearDaySchedule {
+enum class Fields : uint8_t
+{
+ kYearDayIndex = 0,
+ kUserIndex = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearYearDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearYearDaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t yearDayIndex = static_cast<uint8_t>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearYearDaySchedule
+namespace SetHolidaySchedule {
+enum class Fields : uint8_t
+{
+ kHolidayIndex = 0,
+ kLocalStartTime = 1,
+ kLocalEndTime = 2,
+ kOperatingMode = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetHolidaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+ uint32_t localStartTime = static_cast<uint32_t>(0);
+ uint32_t localEndTime = static_cast<uint32_t>(0);
+ OperatingModeEnum operatingMode = static_cast<OperatingModeEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetHolidaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+ uint32_t localStartTime = static_cast<uint32_t>(0);
+ uint32_t localEndTime = static_cast<uint32_t>(0);
+ OperatingModeEnum operatingMode = static_cast<OperatingModeEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetHolidaySchedule
+namespace GetHolidaySchedule {
+enum class Fields : uint8_t
+{
+ kHolidayIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetHolidaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DoorLock::Commands::GetHolidayScheduleResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetHolidaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetHolidaySchedule
+namespace GetHolidayScheduleResponse {
+enum class Fields : uint8_t
+{
+ kHolidayIndex = 0,
+ kStatus = 1,
+ kLocalStartTime = 2,
+ kLocalEndTime = 3,
+ kOperatingMode = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetHolidayScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+ DlStatus status = static_cast<DlStatus>(0);
+ Optional<uint32_t> localStartTime;
+ Optional<uint32_t> localEndTime;
+ Optional<OperatingModeEnum> operatingMode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetHolidayScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+ DlStatus status = static_cast<DlStatus>(0);
+ Optional<uint32_t> localStartTime;
+ Optional<uint32_t> localEndTime;
+ Optional<OperatingModeEnum> operatingMode;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetHolidayScheduleResponse
+namespace ClearHolidaySchedule {
+enum class Fields : uint8_t
+{
+ kHolidayIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearHolidaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearHolidaySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint8_t holidayIndex = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearHolidaySchedule
+namespace SetUser {
+enum class Fields : uint8_t
+{
+ kOperationType = 0,
+ kUserIndex = 1,
+ kUserName = 2,
+ kUserUniqueID = 3,
+ kUserStatus = 4,
+ kUserType = 5,
+ kCredentialRule = 6,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetUser::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DataOperationTypeEnum operationType = static_cast<DataOperationTypeEnum>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DataModel::Nullable<chip::CharSpan> userName;
+ DataModel::Nullable<uint32_t> userUniqueID;
+ DataModel::Nullable<UserStatusEnum> userStatus;
+ DataModel::Nullable<UserTypeEnum> userType;
+ DataModel::Nullable<CredentialRuleEnum> credentialRule;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetUser::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DataOperationTypeEnum operationType = static_cast<DataOperationTypeEnum>(0);
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DataModel::Nullable<chip::CharSpan> userName;
+ DataModel::Nullable<uint32_t> userUniqueID;
+ DataModel::Nullable<UserStatusEnum> userStatus;
+ DataModel::Nullable<UserTypeEnum> userType;
+ DataModel::Nullable<CredentialRuleEnum> credentialRule;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetUser
+namespace GetUser {
+enum class Fields : uint8_t
+{
+ kUserIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetUser::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t userIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DoorLock::Commands::GetUserResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetUser::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetUser
+namespace GetUserResponse {
+enum class Fields : uint8_t
+{
+ kUserIndex = 0,
+ kUserName = 1,
+ kUserUniqueID = 2,
+ kUserStatus = 3,
+ kUserType = 4,
+ kCredentialRule = 5,
+ kCredentials = 6,
+ kCreatorFabricIndex = 7,
+ kLastModifiedFabricIndex = 8,
+ kNextUserIndex = 9,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetUserResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DataModel::Nullable<chip::CharSpan> userName;
+ DataModel::Nullable<uint32_t> userUniqueID;
+ DataModel::Nullable<UserStatusEnum> userStatus;
+ DataModel::Nullable<UserTypeEnum> userType;
+ DataModel::Nullable<CredentialRuleEnum> credentialRule;
+ DataModel::Nullable<DataModel::List<const Structs::CredentialStruct::Type>> credentials;
+ DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
+ DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
+ DataModel::Nullable<uint16_t> nextUserIndex;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetUserResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ DataModel::Nullable<chip::CharSpan> userName;
+ DataModel::Nullable<uint32_t> userUniqueID;
+ DataModel::Nullable<UserStatusEnum> userStatus;
+ DataModel::Nullable<UserTypeEnum> userType;
+ DataModel::Nullable<CredentialRuleEnum> credentialRule;
+ DataModel::Nullable<DataModel::DecodableList<Structs::CredentialStruct::DecodableType>> credentials;
+ DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
+ DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
+ DataModel::Nullable<uint16_t> nextUserIndex;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetUserResponse
+namespace ClearUser {
+enum class Fields : uint8_t
+{
+ kUserIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearUser::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t userIndex = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearUser::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ uint16_t userIndex = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearUser
+namespace SetCredential {
+enum class Fields : uint8_t
+{
+ kOperationType = 0,
+ kCredential = 1,
+ kCredentialData = 2,
+ kUserIndex = 3,
+ kUserStatus = 4,
+ kUserType = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetCredential::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DataOperationTypeEnum operationType = static_cast<DataOperationTypeEnum>(0);
+ Structs::CredentialStruct::Type credential;
+ chip::ByteSpan credentialData;
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<UserStatusEnum> userStatus;
+ DataModel::Nullable<UserTypeEnum> userType;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DoorLock::Commands::SetCredentialResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetCredential::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DataOperationTypeEnum operationType = static_cast<DataOperationTypeEnum>(0);
+ Structs::CredentialStruct::DecodableType credential;
+ chip::ByteSpan credentialData;
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<UserStatusEnum> userStatus;
+ DataModel::Nullable<UserTypeEnum> userType;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetCredential
+namespace SetCredentialResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kUserIndex = 1,
+ kNextCredentialIndex = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetCredentialResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DlStatus status = static_cast<DlStatus>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<uint16_t> nextCredentialIndex;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetCredentialResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DlStatus status = static_cast<DlStatus>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<uint16_t> nextCredentialIndex;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetCredentialResponse
+namespace GetCredentialStatus {
+enum class Fields : uint8_t
+{
+ kCredential = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetCredentialStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Structs::CredentialStruct::Type credential;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::DoorLock::Commands::GetCredentialStatusResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetCredentialStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Structs::CredentialStruct::DecodableType credential;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetCredentialStatus
+namespace GetCredentialStatusResponse {
+enum class Fields : uint8_t
+{
+ kCredentialExists = 0,
+ kUserIndex = 1,
+ kCreatorFabricIndex = 2,
+ kLastModifiedFabricIndex = 3,
+ kNextCredentialIndex = 4,
+ kCredentialData = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetCredentialStatusResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ bool credentialExists = static_cast<bool>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
+ DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
+ DataModel::Nullable<uint16_t> nextCredentialIndex;
+ Optional<DataModel::Nullable<chip::ByteSpan>> credentialData;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetCredentialStatusResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ bool credentialExists = static_cast<bool>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
+ DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
+ DataModel::Nullable<uint16_t> nextCredentialIndex;
+ Optional<DataModel::Nullable<chip::ByteSpan>> credentialData;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetCredentialStatusResponse
+namespace ClearCredential {
+enum class Fields : uint8_t
+{
+ kCredential = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearCredential::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DataModel::Nullable<Structs::CredentialStruct::Type> credential;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearCredential::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DataModel::Nullable<Structs::CredentialStruct::DecodableType> credential;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearCredential
+namespace UnboltDoor {
+enum class Fields : uint8_t
+{
+ kPINCode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UnboltDoor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Optional<chip::ByteSpan> PINCode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UnboltDoor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ Optional<chip::ByteSpan> PINCode;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnboltDoor
+namespace SetAliroReaderConfig {
+enum class Fields : uint8_t
+{
+ kSigningKey = 0,
+ kVerificationKey = 1,
+ kGroupIdentifier = 2,
+ kGroupResolvingKey = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetAliroReaderConfig::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ chip::ByteSpan signingKey;
+ chip::ByteSpan verificationKey;
+ chip::ByteSpan groupIdentifier;
+ Optional<chip::ByteSpan> groupResolvingKey;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetAliroReaderConfig::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ chip::ByteSpan signingKey;
+ chip::ByteSpan verificationKey;
+ chip::ByteSpan groupIdentifier;
+ Optional<chip::ByteSpan> groupResolvingKey;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetAliroReaderConfig
+namespace ClearAliroReaderConfig {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearAliroReaderConfig::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearAliroReaderConfig::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearAliroReaderConfig
+} // namespace Commands
+
+namespace Attributes {
+
+namespace LockState {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LockState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LockState
+namespace LockType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::DoorLock::DlLockType;
+ using DecodableType = chip::app::Clusters::DoorLock::DlLockType;
+ using DecodableArgType = chip::app::Clusters::DoorLock::DlLockType;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LockType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LockType
+namespace ActuatorEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActuatorEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActuatorEnabled
+namespace DoorState {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DoorState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DoorState
+namespace DoorOpenEvents {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DoorOpenEvents::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DoorOpenEvents
+namespace DoorClosedEvents {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DoorClosedEvents::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DoorClosedEvents
+namespace OpenPeriod {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OpenPeriod::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OpenPeriod
+namespace NumberOfTotalUsersSupported {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfTotalUsersSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfTotalUsersSupported
+namespace NumberOfPINUsersSupported {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPINUsersSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfPINUsersSupported
+namespace NumberOfRFIDUsersSupported {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfRFIDUsersSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfRFIDUsersSupported
+namespace NumberOfWeekDaySchedulesSupportedPerUser {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfWeekDaySchedulesSupportedPerUser
+namespace NumberOfYearDaySchedulesSupportedPerUser {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfYearDaySchedulesSupportedPerUser
+namespace NumberOfHolidaySchedulesSupported {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfHolidaySchedulesSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfHolidaySchedulesSupported
+namespace MaxPINCodeLength {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxPINCodeLength::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxPINCodeLength
+namespace MinPINCodeLength {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinPINCodeLength::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinPINCodeLength
+namespace MaxRFIDCodeLength {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxRFIDCodeLength::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxRFIDCodeLength
+namespace MinRFIDCodeLength {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinRFIDCodeLength::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinRFIDCodeLength
+namespace CredentialRulesSupport {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CredentialRulesSupport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CredentialRulesSupport
+namespace NumberOfCredentialsSupportedPerUser {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfCredentialsSupportedPerUser::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfCredentialsSupportedPerUser
+namespace Language {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Language::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 3; }
+};
+} // namespace Language
+namespace LEDSettings {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LEDSettings::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LEDSettings
+namespace AutoRelockTime {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AutoRelockTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AutoRelockTime
+namespace SoundVolume {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoundVolume::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SoundVolume
+namespace OperatingMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::DoorLock::OperatingModeEnum;
+ using DecodableType = chip::app::Clusters::DoorLock::OperatingModeEnum;
+ using DecodableArgType = chip::app::Clusters::DoorLock::OperatingModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperatingMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperatingMode
+namespace SupportedOperatingModes {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedOperatingModes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedOperatingModes
+namespace DefaultConfigurationRegister {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DefaultConfigurationRegister::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DefaultConfigurationRegister
+namespace EnableLocalProgramming {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnableLocalProgramming::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnableLocalProgramming
+namespace EnableOneTouchLocking {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnableOneTouchLocking::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnableOneTouchLocking
+namespace EnableInsideStatusLED {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnableInsideStatusLED::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnableInsideStatusLED
+namespace EnablePrivacyModeButton {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnablePrivacyModeButton::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnablePrivacyModeButton
+namespace LocalProgrammingFeatures {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalProgrammingFeatures::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalProgrammingFeatures
+namespace WrongCodeEntryLimit {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WrongCodeEntryLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WrongCodeEntryLimit
+namespace UserCodeTemporaryDisableTime {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UserCodeTemporaryDisableTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UserCodeTemporaryDisableTime
+namespace SendPINOverTheAir {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SendPINOverTheAir::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SendPINOverTheAir
+namespace RequirePINforRemoteOperation {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RequirePINforRemoteOperation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RequirePINforRemoteOperation
+namespace ExpiringUserTimeout {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ExpiringUserTimeout::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ExpiringUserTimeout
+namespace AliroReaderVerificationKey {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroReaderVerificationKey::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 65; }
+};
+} // namespace AliroReaderVerificationKey
+namespace AliroReaderGroupIdentifier {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroReaderGroupIdentifier::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace AliroReaderGroupIdentifier
+namespace AliroReaderGroupSubIdentifier {
+struct TypeInfo
+{
+ using Type = chip::ByteSpan;
+ using DecodableType = chip::ByteSpan;
+ using DecodableArgType = chip::ByteSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroReaderGroupSubIdentifier::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace AliroReaderGroupSubIdentifier
+namespace AliroExpeditedTransactionSupportedProtocolVersions {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroExpeditedTransactionSupportedProtocolVersions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AliroExpeditedTransactionSupportedProtocolVersions
+namespace AliroGroupResolvingKey {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroGroupResolvingKey::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace AliroGroupResolvingKey
+namespace AliroSupportedBLEUWBProtocolVersions {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroSupportedBLEUWBProtocolVersions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AliroSupportedBLEUWBProtocolVersions
+namespace AliroBLEAdvertisingVersion {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AliroBLEAdvertisingVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AliroBLEAdvertisingVersion
+namespace NumberOfAliroCredentialIssuerKeysSupported {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfAliroCredentialIssuerKeysSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfAliroCredentialIssuerKeysSupported
+namespace NumberOfAliroEndpointKeysSupported {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfAliroEndpointKeysSupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfAliroEndpointKeysSupported
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::LockState::TypeInfo::DecodableType lockState;
+ Attributes::LockType::TypeInfo::DecodableType lockType = static_cast<chip::app::Clusters::DoorLock::DlLockType>(0);
+ Attributes::ActuatorEnabled::TypeInfo::DecodableType actuatorEnabled = static_cast<bool>(0);
+ Attributes::DoorState::TypeInfo::DecodableType doorState;
+ Attributes::DoorOpenEvents::TypeInfo::DecodableType doorOpenEvents = static_cast<uint32_t>(0);
+ Attributes::DoorClosedEvents::TypeInfo::DecodableType doorClosedEvents = static_cast<uint32_t>(0);
+ Attributes::OpenPeriod::TypeInfo::DecodableType openPeriod = static_cast<uint16_t>(0);
+ Attributes::NumberOfTotalUsersSupported::TypeInfo::DecodableType numberOfTotalUsersSupported = static_cast<uint16_t>(0);
+ Attributes::NumberOfPINUsersSupported::TypeInfo::DecodableType numberOfPINUsersSupported = static_cast<uint16_t>(0);
+ Attributes::NumberOfRFIDUsersSupported::TypeInfo::DecodableType numberOfRFIDUsersSupported = static_cast<uint16_t>(0);
+ Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo::DecodableType numberOfWeekDaySchedulesSupportedPerUser =
+ static_cast<uint8_t>(0);
+ Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo::DecodableType numberOfYearDaySchedulesSupportedPerUser =
+ static_cast<uint8_t>(0);
+ Attributes::NumberOfHolidaySchedulesSupported::TypeInfo::DecodableType numberOfHolidaySchedulesSupported =
+ static_cast<uint8_t>(0);
+ Attributes::MaxPINCodeLength::TypeInfo::DecodableType maxPINCodeLength = static_cast<uint8_t>(0);
+ Attributes::MinPINCodeLength::TypeInfo::DecodableType minPINCodeLength = static_cast<uint8_t>(0);
+ Attributes::MaxRFIDCodeLength::TypeInfo::DecodableType maxRFIDCodeLength = static_cast<uint8_t>(0);
+ Attributes::MinRFIDCodeLength::TypeInfo::DecodableType minRFIDCodeLength = static_cast<uint8_t>(0);
+ Attributes::CredentialRulesSupport::TypeInfo::DecodableType credentialRulesSupport =
+ static_cast<chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>>(0);
+ Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo::DecodableType numberOfCredentialsSupportedPerUser =
+ static_cast<uint8_t>(0);
+ Attributes::Language::TypeInfo::DecodableType language;
+ Attributes::LEDSettings::TypeInfo::DecodableType LEDSettings = static_cast<uint8_t>(0);
+ Attributes::AutoRelockTime::TypeInfo::DecodableType autoRelockTime = static_cast<uint32_t>(0);
+ Attributes::SoundVolume::TypeInfo::DecodableType soundVolume = static_cast<uint8_t>(0);
+ Attributes::OperatingMode::TypeInfo::DecodableType operatingMode =
+ static_cast<chip::app::Clusters::DoorLock::OperatingModeEnum>(0);
+ Attributes::SupportedOperatingModes::TypeInfo::DecodableType supportedOperatingModes =
+ static_cast<chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>>(0);
+ Attributes::DefaultConfigurationRegister::TypeInfo::DecodableType defaultConfigurationRegister =
+ static_cast<chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>>(0);
+ Attributes::EnableLocalProgramming::TypeInfo::DecodableType enableLocalProgramming = static_cast<bool>(0);
+ Attributes::EnableOneTouchLocking::TypeInfo::DecodableType enableOneTouchLocking = static_cast<bool>(0);
+ Attributes::EnableInsideStatusLED::TypeInfo::DecodableType enableInsideStatusLED = static_cast<bool>(0);
+ Attributes::EnablePrivacyModeButton::TypeInfo::DecodableType enablePrivacyModeButton = static_cast<bool>(0);
+ Attributes::LocalProgrammingFeatures::TypeInfo::DecodableType localProgrammingFeatures =
+ static_cast<chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>>(0);
+ Attributes::WrongCodeEntryLimit::TypeInfo::DecodableType wrongCodeEntryLimit = static_cast<uint8_t>(0);
+ Attributes::UserCodeTemporaryDisableTime::TypeInfo::DecodableType userCodeTemporaryDisableTime = static_cast<uint8_t>(0);
+ Attributes::SendPINOverTheAir::TypeInfo::DecodableType sendPINOverTheAir = static_cast<bool>(0);
+ Attributes::RequirePINforRemoteOperation::TypeInfo::DecodableType requirePINforRemoteOperation = static_cast<bool>(0);
+ Attributes::ExpiringUserTimeout::TypeInfo::DecodableType expiringUserTimeout = static_cast<uint16_t>(0);
+ Attributes::AliroReaderVerificationKey::TypeInfo::DecodableType aliroReaderVerificationKey;
+ Attributes::AliroReaderGroupIdentifier::TypeInfo::DecodableType aliroReaderGroupIdentifier;
+ Attributes::AliroReaderGroupSubIdentifier::TypeInfo::DecodableType aliroReaderGroupSubIdentifier;
+ Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo::DecodableType
+ aliroExpeditedTransactionSupportedProtocolVersions;
+ Attributes::AliroGroupResolvingKey::TypeInfo::DecodableType aliroGroupResolvingKey;
+ Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo::DecodableType aliroSupportedBLEUWBProtocolVersions;
+ Attributes::AliroBLEAdvertisingVersion::TypeInfo::DecodableType aliroBLEAdvertisingVersion = static_cast<uint8_t>(0);
+ Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo::DecodableType numberOfAliroCredentialIssuerKeysSupported =
+ static_cast<uint16_t>(0);
+ Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo::DecodableType numberOfAliroEndpointKeysSupported =
+ static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace DoorLockAlarm {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kAlarmCode = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DoorLockAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ AlarmCodeEnum alarmCode = static_cast<AlarmCodeEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DoorLockAlarm::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ AlarmCodeEnum alarmCode = static_cast<AlarmCodeEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace DoorLockAlarm
+namespace DoorStateChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kDoorState = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DoorStateChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DoorStateEnum doorState = static_cast<DoorStateEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DoorStateChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ DoorStateEnum doorState = static_cast<DoorStateEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace DoorStateChange
+namespace LockOperation {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kLockOperationType = 0,
+ kOperationSource = 1,
+ kUserIndex = 2,
+ kFabricIndex = 3,
+ kSourceNode = 4,
+ kCredentials = 5,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LockOperation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ LockOperationTypeEnum lockOperationType = static_cast<LockOperationTypeEnum>(0);
+ OperationSourceEnum operationSource = static_cast<OperationSourceEnum>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> fabricIndex;
+ DataModel::Nullable<chip::NodeId> sourceNode;
+ Optional<DataModel::Nullable<DataModel::List<const Structs::CredentialStruct::Type>>> credentials;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LockOperation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ LockOperationTypeEnum lockOperationType = static_cast<LockOperationTypeEnum>(0);
+ OperationSourceEnum operationSource = static_cast<OperationSourceEnum>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> fabricIndex;
+ DataModel::Nullable<chip::NodeId> sourceNode;
+ Optional<DataModel::Nullable<DataModel::DecodableList<Structs::CredentialStruct::DecodableType>>> credentials;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LockOperation
+namespace LockOperationError {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kLockOperationType = 0,
+ kOperationSource = 1,
+ kOperationError = 2,
+ kUserIndex = 3,
+ kFabricIndex = 4,
+ kSourceNode = 5,
+ kCredentials = 6,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LockOperationError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ LockOperationTypeEnum lockOperationType = static_cast<LockOperationTypeEnum>(0);
+ OperationSourceEnum operationSource = static_cast<OperationSourceEnum>(0);
+ OperationErrorEnum operationError = static_cast<OperationErrorEnum>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> fabricIndex;
+ DataModel::Nullable<chip::NodeId> sourceNode;
+ Optional<DataModel::Nullable<DataModel::List<const Structs::CredentialStruct::Type>>> credentials;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LockOperationError::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ LockOperationTypeEnum lockOperationType = static_cast<LockOperationTypeEnum>(0);
+ OperationSourceEnum operationSource = static_cast<OperationSourceEnum>(0);
+ OperationErrorEnum operationError = static_cast<OperationErrorEnum>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> fabricIndex;
+ DataModel::Nullable<chip::NodeId> sourceNode;
+ Optional<DataModel::Nullable<DataModel::DecodableList<Structs::CredentialStruct::DecodableType>>> credentials;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LockOperationError
+namespace LockUserChange {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kLockDataType = 0,
+ kDataOperationType = 1,
+ kOperationSource = 2,
+ kUserIndex = 3,
+ kFabricIndex = 4,
+ kSourceNode = 5,
+ kDataIndex = 6,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LockUserChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ LockDataTypeEnum lockDataType = static_cast<LockDataTypeEnum>(0);
+ DataOperationTypeEnum dataOperationType = static_cast<DataOperationTypeEnum>(0);
+ OperationSourceEnum operationSource = static_cast<OperationSourceEnum>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> fabricIndex;
+ DataModel::Nullable<chip::NodeId> sourceNode;
+ DataModel::Nullable<uint16_t> dataIndex;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LockUserChange::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; }
+
+ LockDataTypeEnum lockDataType = static_cast<LockDataTypeEnum>(0);
+ DataOperationTypeEnum dataOperationType = static_cast<DataOperationTypeEnum>(0);
+ OperationSourceEnum operationSource = static_cast<OperationSourceEnum>(0);
+ DataModel::Nullable<uint16_t> userIndex;
+ DataModel::Nullable<chip::FabricIndex> fabricIndex;
+ DataModel::Nullable<chip::NodeId> sourceNode;
+ DataModel::Nullable<uint16_t> dataIndex;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LockUserChange
+} // namespace Events
+} // namespace DoorLock
+namespace WindowCovering {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace UpOrOpen {
+struct Type;
+struct DecodableType;
+} // namespace UpOrOpen
+
+namespace DownOrClose {
+struct Type;
+struct DecodableType;
+} // namespace DownOrClose
+
+namespace StopMotion {
+struct Type;
+struct DecodableType;
+} // namespace StopMotion
+
+namespace GoToLiftValue {
+struct Type;
+struct DecodableType;
+} // namespace GoToLiftValue
+
+namespace GoToLiftPercentage {
+struct Type;
+struct DecodableType;
+} // namespace GoToLiftPercentage
+
+namespace GoToTiltValue {
+struct Type;
+struct DecodableType;
+} // namespace GoToTiltValue
+
+namespace GoToTiltPercentage {
+struct Type;
+struct DecodableType;
+} // namespace GoToTiltPercentage
+
+} // namespace Commands
+
+namespace Commands {
+namespace UpOrOpen {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UpOrOpen::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UpOrOpen::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpOrOpen
+namespace DownOrClose {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DownOrClose::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DownOrClose::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DownOrClose
+namespace StopMotion {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StopMotion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StopMotion::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopMotion
+namespace GoToLiftValue {
+enum class Fields : uint8_t
+{
+ kLiftValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GoToLiftValue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ uint16_t liftValue = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GoToLiftValue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ uint16_t liftValue = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToLiftValue
+namespace GoToLiftPercentage {
+enum class Fields : uint8_t
+{
+ kLiftPercent100thsValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GoToLiftPercentage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ chip::Percent100ths liftPercent100thsValue = static_cast<chip::Percent100ths>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GoToLiftPercentage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ chip::Percent100ths liftPercent100thsValue = static_cast<chip::Percent100ths>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToLiftPercentage
+namespace GoToTiltValue {
+enum class Fields : uint8_t
+{
+ kTiltValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GoToTiltValue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ uint16_t tiltValue = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GoToTiltValue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ uint16_t tiltValue = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToTiltValue
+namespace GoToTiltPercentage {
+enum class Fields : uint8_t
+{
+ kTiltPercent100thsValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GoToTiltPercentage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ chip::Percent100ths tiltPercent100thsValue = static_cast<chip::Percent100ths>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GoToTiltPercentage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ chip::Percent100ths tiltPercent100thsValue = static_cast<chip::Percent100ths>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GoToTiltPercentage
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Type {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::WindowCovering::Type;
+ using DecodableType = chip::app::Clusters::WindowCovering::Type;
+ using DecodableArgType = chip::app::Clusters::WindowCovering::Type;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Type::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Type
+namespace PhysicalClosedLimitLift {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalClosedLimitLift::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalClosedLimitLift
+namespace PhysicalClosedLimitTilt {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalClosedLimitTilt::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalClosedLimitTilt
+namespace CurrentPositionLift {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionLift::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPositionLift
+namespace CurrentPositionTilt {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionTilt::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPositionTilt
+namespace NumberOfActuationsLift {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfActuationsLift::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfActuationsLift
+namespace NumberOfActuationsTilt {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfActuationsTilt::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfActuationsTilt
+namespace ConfigStatus {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ConfigStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ConfigStatus
+namespace CurrentPositionLiftPercentage {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionLiftPercentage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPositionLiftPercentage
+namespace CurrentPositionTiltPercentage {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionTiltPercentage::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPositionTiltPercentage
+namespace OperationalStatus {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationalStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationalStatus
+namespace TargetPositionLiftPercent100ths {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent100ths> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TargetPositionLiftPercent100ths::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TargetPositionLiftPercent100ths
+namespace TargetPositionTiltPercent100ths {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent100ths> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TargetPositionTiltPercent100ths::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TargetPositionTiltPercent100ths
+namespace EndProductType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::WindowCovering::EndProductType;
+ using DecodableType = chip::app::Clusters::WindowCovering::EndProductType;
+ using DecodableArgType = chip::app::Clusters::WindowCovering::EndProductType;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EndProductType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EndProductType
+namespace CurrentPositionLiftPercent100ths {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent100ths> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionLiftPercent100ths::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPositionLiftPercent100ths
+namespace CurrentPositionTiltPercent100ths {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent100ths>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent100ths> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPositionTiltPercent100ths::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentPositionTiltPercent100ths
+namespace InstalledOpenLimitLift {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InstalledOpenLimitLift::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InstalledOpenLimitLift
+namespace InstalledClosedLimitLift {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InstalledClosedLimitLift::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InstalledClosedLimitLift
+namespace InstalledOpenLimitTilt {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InstalledOpenLimitTilt::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InstalledOpenLimitTilt
+namespace InstalledClosedLimitTilt {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InstalledClosedLimitTilt::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InstalledClosedLimitTilt
+namespace Mode {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::WindowCovering::Mode>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::WindowCovering::Mode>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::WindowCovering::Mode>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Mode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Mode
+namespace SafetyStatus {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SafetyStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SafetyStatus
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Type::TypeInfo::DecodableType type = static_cast<chip::app::Clusters::WindowCovering::Type>(0);
+ Attributes::PhysicalClosedLimitLift::TypeInfo::DecodableType physicalClosedLimitLift = static_cast<uint16_t>(0);
+ Attributes::PhysicalClosedLimitTilt::TypeInfo::DecodableType physicalClosedLimitTilt = static_cast<uint16_t>(0);
+ Attributes::CurrentPositionLift::TypeInfo::DecodableType currentPositionLift;
+ Attributes::CurrentPositionTilt::TypeInfo::DecodableType currentPositionTilt;
+ Attributes::NumberOfActuationsLift::TypeInfo::DecodableType numberOfActuationsLift = static_cast<uint16_t>(0);
+ Attributes::NumberOfActuationsTilt::TypeInfo::DecodableType numberOfActuationsTilt = static_cast<uint16_t>(0);
+ Attributes::ConfigStatus::TypeInfo::DecodableType configStatus =
+ static_cast<chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>>(0);
+ Attributes::CurrentPositionLiftPercentage::TypeInfo::DecodableType currentPositionLiftPercentage;
+ Attributes::CurrentPositionTiltPercentage::TypeInfo::DecodableType currentPositionTiltPercentage;
+ Attributes::OperationalStatus::TypeInfo::DecodableType operationalStatus =
+ static_cast<chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>>(0);
+ Attributes::TargetPositionLiftPercent100ths::TypeInfo::DecodableType targetPositionLiftPercent100ths;
+ Attributes::TargetPositionTiltPercent100ths::TypeInfo::DecodableType targetPositionTiltPercent100ths;
+ Attributes::EndProductType::TypeInfo::DecodableType endProductType =
+ static_cast<chip::app::Clusters::WindowCovering::EndProductType>(0);
+ Attributes::CurrentPositionLiftPercent100ths::TypeInfo::DecodableType currentPositionLiftPercent100ths;
+ Attributes::CurrentPositionTiltPercent100ths::TypeInfo::DecodableType currentPositionTiltPercent100ths;
+ Attributes::InstalledOpenLimitLift::TypeInfo::DecodableType installedOpenLimitLift = static_cast<uint16_t>(0);
+ Attributes::InstalledClosedLimitLift::TypeInfo::DecodableType installedClosedLimitLift = static_cast<uint16_t>(0);
+ Attributes::InstalledOpenLimitTilt::TypeInfo::DecodableType installedOpenLimitTilt = static_cast<uint16_t>(0);
+ Attributes::InstalledClosedLimitTilt::TypeInfo::DecodableType installedClosedLimitTilt = static_cast<uint16_t>(0);
+ Attributes::Mode::TypeInfo::DecodableType mode = static_cast<chip::BitMask<chip::app::Clusters::WindowCovering::Mode>>(0);
+ Attributes::SafetyStatus::TypeInfo::DecodableType safetyStatus =
+ static_cast<chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace WindowCovering
+namespace ServiceArea {
+namespace Structs {
+namespace LandmarkInfoStruct {
+enum class Fields : uint8_t
+{
+ kLandmarkTag = 0,
+ kRelativePositionTag = 1,
+};
+
+struct Type
+{
+public:
+ Globals::LandmarkTag landmarkTag = static_cast<Globals::LandmarkTag>(0);
+ DataModel::Nullable<Globals::RelativePositionTag> relativePositionTag;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace LandmarkInfoStruct
+namespace AreaInfoStruct {
+enum class Fields : uint8_t
+{
+ kLocationInfo = 0,
+ kLandmarkInfo = 1,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<Globals::Structs::LocationDescriptorStruct::Type> locationInfo;
+ DataModel::Nullable<Structs::LandmarkInfoStruct::Type> landmarkInfo;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AreaInfoStruct
+namespace AreaStruct {
+enum class Fields : uint8_t
+{
+ kAreaID = 0,
+ kMapID = 1,
+ kAreaInfo = 2,
+};
+
+struct Type
+{
+public:
+ uint32_t areaID = static_cast<uint32_t>(0);
+ DataModel::Nullable<uint32_t> mapID;
+ Structs::AreaInfoStruct::Type areaInfo;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AreaStruct
+namespace MapStruct {
+enum class Fields : uint8_t
+{
+ kMapID = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ uint32_t mapID = static_cast<uint32_t>(0);
+ chip::CharSpan name;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MapStruct
+namespace ProgressStruct {
+enum class Fields : uint8_t
+{
+ kAreaID = 0,
+ kStatus = 1,
+ kTotalOperationalTime = 2,
+ kEstimatedTime = 3,
+};
+
+struct Type
+{
+public:
+ uint32_t areaID = static_cast<uint32_t>(0);
+ OperationalStatusEnum status = static_cast<OperationalStatusEnum>(0);
+ Optional<DataModel::Nullable<uint32_t>> totalOperationalTime;
+ Optional<DataModel::Nullable<uint32_t>> estimatedTime;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ProgressStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SelectAreas {
+struct Type;
+struct DecodableType;
+} // namespace SelectAreas
+
+namespace SelectAreasResponse {
+struct Type;
+struct DecodableType;
+} // namespace SelectAreasResponse
+
+namespace SkipArea {
+struct Type;
+struct DecodableType;
+} // namespace SkipArea
+
+namespace SkipAreaResponse {
+struct Type;
+struct DecodableType;
+} // namespace SkipAreaResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace SelectAreas {
+enum class Fields : uint8_t
+{
+ kNewAreas = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SelectAreas::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ DataModel::List<const uint32_t> newAreas;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ServiceArea::Commands::SelectAreasResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SelectAreas::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ DataModel::DecodableList<uint32_t> newAreas;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelectAreas
+namespace SelectAreasResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SelectAreasResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ SelectAreasStatus status = static_cast<SelectAreasStatus>(0);
+ chip::CharSpan statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SelectAreasResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ SelectAreasStatus status = static_cast<SelectAreasStatus>(0);
+ chip::CharSpan statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelectAreasResponse
+namespace SkipArea {
+enum class Fields : uint8_t
+{
+ kSkippedArea = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SkipArea::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ uint32_t skippedArea = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ServiceArea::Commands::SkipAreaResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SkipArea::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ uint32_t skippedArea = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SkipArea
+namespace SkipAreaResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kStatusText = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SkipAreaResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ SkipAreaStatus status = static_cast<SkipAreaStatus>(0);
+ chip::CharSpan statusText;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SkipAreaResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ SkipAreaStatus status = static_cast<SkipAreaStatus>(0);
+ chip::CharSpan statusText;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SkipAreaResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedAreas {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ServiceArea::Structs::AreaStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::ServiceArea::Structs::AreaStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ServiceArea::Structs::AreaStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedAreas::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedAreas
+namespace SupportedMaps {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ServiceArea::Structs::MapStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::ServiceArea::Structs::MapStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ServiceArea::Structs::MapStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedMaps::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedMaps
+namespace SelectedAreas {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const uint32_t>;
+ using DecodableType = chip::app::DataModel::DecodableList<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SelectedAreas::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SelectedAreas
+namespace CurrentArea {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentArea::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentArea
+namespace EstimatedEndTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EstimatedEndTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EstimatedEndTime
+namespace Progress {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ServiceArea::Structs::ProgressStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ServiceArea::Structs::ProgressStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ServiceArea::Structs::ProgressStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Progress::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Progress
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ServiceArea::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedAreas::TypeInfo::DecodableType supportedAreas;
+ Attributes::SupportedMaps::TypeInfo::DecodableType supportedMaps;
+ Attributes::SelectedAreas::TypeInfo::DecodableType selectedAreas;
+ Attributes::CurrentArea::TypeInfo::DecodableType currentArea;
+ Attributes::EstimatedEndTime::TypeInfo::DecodableType estimatedEndTime;
+ Attributes::Progress::TypeInfo::DecodableType progress;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ServiceArea
+namespace PumpConfigurationAndControl {
+
+namespace Attributes {
+
+namespace MaxPressure {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxPressure::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxPressure
+namespace MaxSpeed {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxSpeed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxSpeed
+namespace MaxFlow {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxFlow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxFlow
+namespace MinConstPressure {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinConstPressure::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinConstPressure
+namespace MaxConstPressure {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstPressure::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxConstPressure
+namespace MinCompPressure {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinCompPressure::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinCompPressure
+namespace MaxCompPressure {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxCompPressure::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxCompPressure
+namespace MinConstSpeed {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinConstSpeed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinConstSpeed
+namespace MaxConstSpeed {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstSpeed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxConstSpeed
+namespace MinConstFlow {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinConstFlow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinConstFlow
+namespace MaxConstFlow {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstFlow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxConstFlow
+namespace MinConstTemp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinConstTemp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinConstTemp
+namespace MaxConstTemp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxConstTemp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxConstTemp
+namespace PumpStatus {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PumpStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PumpStatus
+namespace EffectiveOperationMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum;
+ using DecodableType = chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum;
+ using DecodableArgType = chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EffectiveOperationMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EffectiveOperationMode
+namespace EffectiveControlMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum;
+ using DecodableType = chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum;
+ using DecodableArgType = chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EffectiveControlMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EffectiveControlMode
+namespace Capacity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Capacity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Capacity
+namespace Speed {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Speed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Speed
+namespace LifetimeRunningHours {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LifetimeRunningHours::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LifetimeRunningHours
+namespace Power {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Power::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Power
+namespace LifetimeEnergyConsumed {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LifetimeEnergyConsumed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LifetimeEnergyConsumed
+namespace OperationMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum;
+ using DecodableType = chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum;
+ using DecodableArgType = chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OperationMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OperationMode
+namespace ControlMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum;
+ using DecodableType = chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum;
+ using DecodableArgType = chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ControlMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ControlMode
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MaxPressure::TypeInfo::DecodableType maxPressure;
+ Attributes::MaxSpeed::TypeInfo::DecodableType maxSpeed;
+ Attributes::MaxFlow::TypeInfo::DecodableType maxFlow;
+ Attributes::MinConstPressure::TypeInfo::DecodableType minConstPressure;
+ Attributes::MaxConstPressure::TypeInfo::DecodableType maxConstPressure;
+ Attributes::MinCompPressure::TypeInfo::DecodableType minCompPressure;
+ Attributes::MaxCompPressure::TypeInfo::DecodableType maxCompPressure;
+ Attributes::MinConstSpeed::TypeInfo::DecodableType minConstSpeed;
+ Attributes::MaxConstSpeed::TypeInfo::DecodableType maxConstSpeed;
+ Attributes::MinConstFlow::TypeInfo::DecodableType minConstFlow;
+ Attributes::MaxConstFlow::TypeInfo::DecodableType maxConstFlow;
+ Attributes::MinConstTemp::TypeInfo::DecodableType minConstTemp;
+ Attributes::MaxConstTemp::TypeInfo::DecodableType maxConstTemp;
+ Attributes::PumpStatus::TypeInfo::DecodableType pumpStatus =
+ static_cast<chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>>(0);
+ Attributes::EffectiveOperationMode::TypeInfo::DecodableType effectiveOperationMode =
+ static_cast<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>(0);
+ Attributes::EffectiveControlMode::TypeInfo::DecodableType effectiveControlMode =
+ static_cast<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>(0);
+ Attributes::Capacity::TypeInfo::DecodableType capacity;
+ Attributes::Speed::TypeInfo::DecodableType speed;
+ Attributes::LifetimeRunningHours::TypeInfo::DecodableType lifetimeRunningHours;
+ Attributes::Power::TypeInfo::DecodableType power;
+ Attributes::LifetimeEnergyConsumed::TypeInfo::DecodableType lifetimeEnergyConsumed;
+ Attributes::OperationMode::TypeInfo::DecodableType operationMode =
+ static_cast<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>(0);
+ Attributes::ControlMode::TypeInfo::DecodableType controlMode =
+ static_cast<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace SupplyVoltageLow {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SupplyVoltageLow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SupplyVoltageLow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SupplyVoltageLow
+namespace SupplyVoltageHigh {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SupplyVoltageHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SupplyVoltageHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SupplyVoltageHigh
+namespace PowerMissingPhase {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PowerMissingPhase::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PowerMissingPhase::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PowerMissingPhase
+namespace SystemPressureLow {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SystemPressureLow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SystemPressureLow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SystemPressureLow
+namespace SystemPressureHigh {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SystemPressureHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SystemPressureHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SystemPressureHigh
+namespace DryRunning {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DryRunning::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::DryRunning::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace DryRunning
+namespace MotorTemperatureHigh {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MotorTemperatureHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::MotorTemperatureHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace MotorTemperatureHigh
+namespace PumpMotorFatalFailure {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PumpMotorFatalFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PumpMotorFatalFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PumpMotorFatalFailure
+namespace ElectronicTemperatureHigh {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ElectronicTemperatureHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ElectronicTemperatureHigh::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ElectronicTemperatureHigh
+namespace PumpBlocked {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PumpBlocked::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PumpBlocked::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PumpBlocked
+namespace SensorFailure {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SensorFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SensorFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SensorFailure
+namespace ElectronicNonFatalFailure {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ElectronicNonFatalFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ElectronicNonFatalFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ElectronicNonFatalFailure
+namespace ElectronicFatalFailure {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ElectronicFatalFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ElectronicFatalFailure::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ElectronicFatalFailure
+namespace GeneralFault {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::GeneralFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::GeneralFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace GeneralFault
+namespace Leakage {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Leakage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Leakage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Leakage
+namespace AirDetection {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AirDetection::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AirDetection::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AirDetection
+namespace TurbineOperation {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TurbineOperation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TurbineOperation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TurbineOperation
+} // namespace Events
+} // namespace PumpConfigurationAndControl
+namespace Thermostat {
+namespace Structs {
+namespace ScheduleTransitionStruct {
+enum class Fields : uint8_t
+{
+ kDayOfWeek = 0,
+ kTransitionTime = 1,
+ kPresetHandle = 2,
+ kSystemMode = 3,
+ kCoolingSetpoint = 4,
+ kHeatingSetpoint = 5,
+};
+
+struct Type
+{
+public:
+ chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeek = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ Optional<chip::ByteSpan> presetHandle;
+ Optional<SystemModeEnum> systemMode;
+ Optional<int16_t> coolingSetpoint;
+ Optional<int16_t> heatingSetpoint;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ScheduleTransitionStruct
+namespace ScheduleStruct {
+enum class Fields : uint8_t
+{
+ kScheduleHandle = 0,
+ kSystemMode = 1,
+ kName = 2,
+ kPresetHandle = 3,
+ kTransitions = 4,
+ kBuiltIn = 5,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<chip::ByteSpan> scheduleHandle;
+ SystemModeEnum systemMode = static_cast<SystemModeEnum>(0);
+ Optional<chip::CharSpan> name;
+ Optional<chip::ByteSpan> presetHandle;
+ DataModel::List<const Structs::ScheduleTransitionStruct::Type> transitions;
+ DataModel::Nullable<bool> builtIn;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::Nullable<chip::ByteSpan> scheduleHandle;
+ SystemModeEnum systemMode = static_cast<SystemModeEnum>(0);
+ Optional<chip::CharSpan> name;
+ Optional<chip::ByteSpan> presetHandle;
+ DataModel::DecodableList<Structs::ScheduleTransitionStruct::DecodableType> transitions;
+ DataModel::Nullable<bool> builtIn;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ScheduleStruct
+namespace PresetStruct {
+enum class Fields : uint8_t
+{
+ kPresetHandle = 0,
+ kPresetScenario = 1,
+ kName = 2,
+ kCoolingSetpoint = 3,
+ kHeatingSetpoint = 4,
+ kBuiltIn = 5,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<chip::ByteSpan> presetHandle;
+ PresetScenarioEnum presetScenario = static_cast<PresetScenarioEnum>(0);
+ Optional<DataModel::Nullable<chip::CharSpan>> name;
+ Optional<int16_t> coolingSetpoint;
+ Optional<int16_t> heatingSetpoint;
+ DataModel::Nullable<bool> builtIn;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace PresetStruct
+namespace PresetTypeStruct {
+enum class Fields : uint8_t
+{
+ kPresetScenario = 0,
+ kNumberOfPresets = 1,
+ kPresetTypeFeatures = 2,
+};
+
+struct Type
+{
+public:
+ PresetScenarioEnum presetScenario = static_cast<PresetScenarioEnum>(0);
+ uint8_t numberOfPresets = static_cast<uint8_t>(0);
+ chip::BitMask<PresetTypeFeaturesBitmap> presetTypeFeatures = static_cast<chip::BitMask<PresetTypeFeaturesBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace PresetTypeStruct
+namespace ScheduleTypeStruct {
+enum class Fields : uint8_t
+{
+ kSystemMode = 0,
+ kNumberOfSchedules = 1,
+ kScheduleTypeFeatures = 2,
+};
+
+struct Type
+{
+public:
+ SystemModeEnum systemMode = static_cast<SystemModeEnum>(0);
+ uint8_t numberOfSchedules = static_cast<uint8_t>(0);
+ chip::BitMask<ScheduleTypeFeaturesBitmap> scheduleTypeFeatures = static_cast<chip::BitMask<ScheduleTypeFeaturesBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ScheduleTypeStruct
+namespace WeeklyScheduleTransitionStruct {
+enum class Fields : uint8_t
+{
+ kTransitionTime = 0,
+ kHeatSetpoint = 1,
+ kCoolSetpoint = 2,
+};
+
+struct Type
+{
+public:
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ DataModel::Nullable<int16_t> heatSetpoint;
+ DataModel::Nullable<int16_t> coolSetpoint;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace WeeklyScheduleTransitionStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SetpointRaiseLower {
+struct Type;
+struct DecodableType;
+} // namespace SetpointRaiseLower
+
+namespace GetWeeklyScheduleResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetWeeklyScheduleResponse
+
+namespace SetWeeklySchedule {
+struct Type;
+struct DecodableType;
+} // namespace SetWeeklySchedule
+
+namespace GetWeeklySchedule {
+struct Type;
+struct DecodableType;
+} // namespace GetWeeklySchedule
+
+namespace ClearWeeklySchedule {
+struct Type;
+struct DecodableType;
+} // namespace ClearWeeklySchedule
+
+namespace SetActiveScheduleRequest {
+struct Type;
+struct DecodableType;
+} // namespace SetActiveScheduleRequest
+
+namespace SetActivePresetRequest {
+struct Type;
+struct DecodableType;
+} // namespace SetActivePresetRequest
+
+namespace AtomicResponse {
+struct Type;
+struct DecodableType;
+} // namespace AtomicResponse
+
+namespace AtomicRequest {
+struct Type;
+struct DecodableType;
+} // namespace AtomicRequest
+
+} // namespace Commands
+
+namespace Commands {
+namespace SetpointRaiseLower {
+enum class Fields : uint8_t
+{
+ kMode = 0,
+ kAmount = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetpointRaiseLower::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ SetpointRaiseLowerModeEnum mode = static_cast<SetpointRaiseLowerModeEnum>(0);
+ int8_t amount = static_cast<int8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetpointRaiseLower::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ SetpointRaiseLowerModeEnum mode = static_cast<SetpointRaiseLowerModeEnum>(0);
+ int8_t amount = static_cast<int8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetpointRaiseLower
+namespace GetWeeklyScheduleResponse {
+enum class Fields : uint8_t
+{
+ kNumberOfTransitionsForSequence = 0,
+ kDayOfWeekForSequence = 1,
+ kModeForSequence = 2,
+ kTransitions = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetWeeklyScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
+ chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ chip::BitMask<ScheduleModeBitmap> modeForSequence = static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
+ DataModel::List<const Structs::WeeklyScheduleTransitionStruct::Type> transitions;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetWeeklyScheduleResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
+ chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ chip::BitMask<ScheduleModeBitmap> modeForSequence = static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
+ DataModel::DecodableList<Structs::WeeklyScheduleTransitionStruct::DecodableType> transitions;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetWeeklyScheduleResponse
+namespace SetWeeklySchedule {
+enum class Fields : uint8_t
+{
+ kNumberOfTransitionsForSequence = 0,
+ kDayOfWeekForSequence = 1,
+ kModeForSequence = 2,
+ kTransitions = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetWeeklySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
+ chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ chip::BitMask<ScheduleModeBitmap> modeForSequence = static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
+ DataModel::List<const Structs::WeeklyScheduleTransitionStruct::Type> transitions;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetWeeklySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
+ chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ chip::BitMask<ScheduleModeBitmap> modeForSequence = static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
+ DataModel::DecodableList<Structs::WeeklyScheduleTransitionStruct::DecodableType> transitions;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetWeeklySchedule
+namespace GetWeeklySchedule {
+enum class Fields : uint8_t
+{
+ kDaysToReturn = 0,
+ kModeToReturn = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetWeeklySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ chip::BitMask<ScheduleDayOfWeekBitmap> daysToReturn = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ chip::BitMask<ScheduleModeBitmap> modeToReturn = static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Thermostat::Commands::GetWeeklyScheduleResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetWeeklySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ chip::BitMask<ScheduleDayOfWeekBitmap> daysToReturn = static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
+ chip::BitMask<ScheduleModeBitmap> modeToReturn = static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetWeeklySchedule
+namespace ClearWeeklySchedule {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ClearWeeklySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ClearWeeklySchedule::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ClearWeeklySchedule
+namespace SetActiveScheduleRequest {
+enum class Fields : uint8_t
+{
+ kScheduleHandle = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetActiveScheduleRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ chip::ByteSpan scheduleHandle;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetActiveScheduleRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ chip::ByteSpan scheduleHandle;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetActiveScheduleRequest
+namespace SetActivePresetRequest {
+enum class Fields : uint8_t
+{
+ kPresetHandle = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetActivePresetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ DataModel::Nullable<chip::ByteSpan> presetHandle;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetActivePresetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ DataModel::Nullable<chip::ByteSpan> presetHandle;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetActivePresetRequest
+namespace AtomicResponse {
+enum class Fields : uint8_t
+{
+ kStatusCode = 0,
+ kAttributeStatus = 1,
+ kTimeout = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AtomicResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ uint8_t statusCode = static_cast<uint8_t>(0);
+ DataModel::List<const Globals::Structs::AtomicAttributeStatusStruct::Type> attributeStatus;
+ Optional<uint16_t> timeout;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AtomicResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ uint8_t statusCode = static_cast<uint8_t>(0);
+ DataModel::DecodableList<Globals::Structs::AtomicAttributeStatusStruct::DecodableType> attributeStatus;
+ Optional<uint16_t> timeout;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AtomicResponse
+namespace AtomicRequest {
+enum class Fields : uint8_t
+{
+ kRequestType = 0,
+ kAttributeRequests = 1,
+ kTimeout = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AtomicRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ Globals::AtomicRequestTypeEnum requestType = static_cast<Globals::AtomicRequestTypeEnum>(0);
+ DataModel::List<const chip::AttributeId> attributeRequests;
+ Optional<uint16_t> timeout;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Thermostat::Commands::AtomicResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AtomicRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ Globals::AtomicRequestTypeEnum requestType = static_cast<Globals::AtomicRequestTypeEnum>(0);
+ DataModel::DecodableList<chip::AttributeId> attributeRequests;
+ Optional<uint16_t> timeout;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AtomicRequest
+} // namespace Commands
+
+namespace Attributes {
+
+namespace LocalTemperature {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalTemperature::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalTemperature
+namespace OutdoorTemperature {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OutdoorTemperature::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OutdoorTemperature
+namespace Occupancy {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Occupancy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Occupancy
+namespace AbsMinHeatSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AbsMinHeatSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AbsMinHeatSetpointLimit
+namespace AbsMaxHeatSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AbsMaxHeatSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AbsMaxHeatSetpointLimit
+namespace AbsMinCoolSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AbsMinCoolSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AbsMinCoolSetpointLimit
+namespace AbsMaxCoolSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AbsMaxCoolSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AbsMaxCoolSetpointLimit
+namespace PICoolingDemand {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PICoolingDemand::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PICoolingDemand
+namespace PIHeatingDemand {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PIHeatingDemand::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PIHeatingDemand
+namespace HVACSystemTypeConfiguration {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HVACSystemTypeConfiguration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HVACSystemTypeConfiguration
+namespace LocalTemperatureCalibration {
+struct TypeInfo
+{
+ using Type = int8_t;
+ using DecodableType = int8_t;
+ using DecodableArgType = int8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalTemperatureCalibration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalTemperatureCalibration
+namespace OccupiedCoolingSetpoint {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedCoolingSetpoint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupiedCoolingSetpoint
+namespace OccupiedHeatingSetpoint {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedHeatingSetpoint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupiedHeatingSetpoint
+namespace UnoccupiedCoolingSetpoint {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedCoolingSetpoint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UnoccupiedCoolingSetpoint
+namespace UnoccupiedHeatingSetpoint {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedHeatingSetpoint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UnoccupiedHeatingSetpoint
+namespace MinHeatSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinHeatSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinHeatSetpointLimit
+namespace MaxHeatSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxHeatSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxHeatSetpointLimit
+namespace MinCoolSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinCoolSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinCoolSetpointLimit
+namespace MaxCoolSetpointLimit {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxCoolSetpointLimit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxCoolSetpointLimit
+namespace MinSetpointDeadBand {
+struct TypeInfo
+{
+ using Type = int8_t;
+ using DecodableType = int8_t;
+ using DecodableArgType = int8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinSetpointDeadBand::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinSetpointDeadBand
+namespace RemoteSensing {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RemoteSensing::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RemoteSensing
+namespace ControlSequenceOfOperation {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ControlSequenceOfOperation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ControlSequenceOfOperation
+namespace SystemMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::SystemModeEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::SystemModeEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::SystemModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SystemMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SystemMode
+namespace ThermostatRunningMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ThermostatRunningModeEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ThermostatRunningModeEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ThermostatRunningModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThermostatRunningMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThermostatRunningMode
+namespace StartOfWeek {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::StartOfWeekEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::StartOfWeekEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::StartOfWeekEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartOfWeek::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartOfWeek
+namespace NumberOfWeeklyTransitions {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfWeeklyTransitions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfWeeklyTransitions
+namespace NumberOfDailyTransitions {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfDailyTransitions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfDailyTransitions
+namespace TemperatureSetpointHold {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureSetpointHold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TemperatureSetpointHold
+namespace TemperatureSetpointHoldDuration {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureSetpointHoldDuration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TemperatureSetpointHoldDuration
+namespace ThermostatProgrammingOperationMode {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThermostatProgrammingOperationMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThermostatProgrammingOperationMode
+namespace ThermostatRunningState {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThermostatRunningState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThermostatRunningState
+namespace SetpointChangeSource {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::SetpointChangeSourceEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::SetpointChangeSourceEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::SetpointChangeSourceEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SetpointChangeSource::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SetpointChangeSource
+namespace SetpointChangeAmount {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SetpointChangeAmount::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SetpointChangeAmount
+namespace SetpointChangeSourceTimestamp {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SetpointChangeSourceTimestamp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SetpointChangeSourceTimestamp
+namespace OccupiedSetback {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedSetback::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupiedSetback
+namespace OccupiedSetbackMin {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedSetbackMin::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupiedSetbackMin
+namespace OccupiedSetbackMax {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupiedSetbackMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupiedSetbackMax
+namespace UnoccupiedSetback {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedSetback::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UnoccupiedSetback
+namespace UnoccupiedSetbackMin {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedSetbackMin::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UnoccupiedSetbackMin
+namespace UnoccupiedSetbackMax {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UnoccupiedSetbackMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UnoccupiedSetbackMax
+namespace EmergencyHeatDelta {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EmergencyHeatDelta::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EmergencyHeatDelta
+namespace ACType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ACTypeEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ACTypeEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ACTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACType
+namespace ACCapacity {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACCapacity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACCapacity
+namespace ACRefrigerantType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACRefrigerantType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACRefrigerantType
+namespace ACCompressorType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ACCompressorTypeEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ACCompressorTypeEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ACCompressorTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACCompressorType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACCompressorType
+namespace ACErrorCode {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACErrorCode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACErrorCode
+namespace ACLouverPosition {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ACLouverPositionEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ACLouverPositionEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ACLouverPositionEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACLouverPosition::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACLouverPosition
+namespace ACCoilTemperature {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACCoilTemperature::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACCoilTemperature
+namespace ACCapacityformat {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Thermostat::ACCapacityFormatEnum;
+ using DecodableType = chip::app::Clusters::Thermostat::ACCapacityFormatEnum;
+ using DecodableArgType = chip::app::Clusters::Thermostat::ACCapacityFormatEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ACCapacityformat::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ACCapacityformat
+namespace PresetTypes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::PresetTypeStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::PresetTypeStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::PresetTypeStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PresetTypes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PresetTypes
+namespace ScheduleTypes {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::ScheduleTypeStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::ScheduleTypeStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::ScheduleTypeStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScheduleTypes::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScheduleTypes
+namespace NumberOfPresets {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPresets::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfPresets
+namespace NumberOfSchedules {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfSchedules::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfSchedules
+namespace NumberOfScheduleTransitions {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfScheduleTransitions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfScheduleTransitions
+namespace NumberOfScheduleTransitionPerDay {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfScheduleTransitionPerDay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfScheduleTransitionPerDay
+namespace ActivePresetHandle {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActivePresetHandle::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace ActivePresetHandle
+namespace ActiveScheduleHandle {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveScheduleHandle::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace ActiveScheduleHandle
+namespace Presets {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::PresetStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::PresetStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::PresetStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Presets::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Presets
+namespace Schedules {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::ScheduleStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::ScheduleStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Thermostat::Structs::ScheduleStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Schedules::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Schedules
+namespace SetpointHoldExpiryTimestamp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SetpointHoldExpiryTimestamp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SetpointHoldExpiryTimestamp
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::LocalTemperature::TypeInfo::DecodableType localTemperature;
+ Attributes::OutdoorTemperature::TypeInfo::DecodableType outdoorTemperature;
+ Attributes::Occupancy::TypeInfo::DecodableType occupancy =
+ static_cast<chip::BitMask<chip::app::Clusters::Thermostat::OccupancyBitmap>>(0);
+ Attributes::AbsMinHeatSetpointLimit::TypeInfo::DecodableType absMinHeatSetpointLimit = static_cast<int16_t>(0);
+ Attributes::AbsMaxHeatSetpointLimit::TypeInfo::DecodableType absMaxHeatSetpointLimit = static_cast<int16_t>(0);
+ Attributes::AbsMinCoolSetpointLimit::TypeInfo::DecodableType absMinCoolSetpointLimit = static_cast<int16_t>(0);
+ Attributes::AbsMaxCoolSetpointLimit::TypeInfo::DecodableType absMaxCoolSetpointLimit = static_cast<int16_t>(0);
+ Attributes::PICoolingDemand::TypeInfo::DecodableType PICoolingDemand = static_cast<uint8_t>(0);
+ Attributes::PIHeatingDemand::TypeInfo::DecodableType PIHeatingDemand = static_cast<uint8_t>(0);
+ Attributes::HVACSystemTypeConfiguration::TypeInfo::DecodableType HVACSystemTypeConfiguration =
+ static_cast<chip::BitMask<chip::app::Clusters::Thermostat::HVACSystemTypeBitmap>>(0);
+ Attributes::LocalTemperatureCalibration::TypeInfo::DecodableType localTemperatureCalibration = static_cast<int8_t>(0);
+ Attributes::OccupiedCoolingSetpoint::TypeInfo::DecodableType occupiedCoolingSetpoint = static_cast<int16_t>(0);
+ Attributes::OccupiedHeatingSetpoint::TypeInfo::DecodableType occupiedHeatingSetpoint = static_cast<int16_t>(0);
+ Attributes::UnoccupiedCoolingSetpoint::TypeInfo::DecodableType unoccupiedCoolingSetpoint = static_cast<int16_t>(0);
+ Attributes::UnoccupiedHeatingSetpoint::TypeInfo::DecodableType unoccupiedHeatingSetpoint = static_cast<int16_t>(0);
+ Attributes::MinHeatSetpointLimit::TypeInfo::DecodableType minHeatSetpointLimit = static_cast<int16_t>(0);
+ Attributes::MaxHeatSetpointLimit::TypeInfo::DecodableType maxHeatSetpointLimit = static_cast<int16_t>(0);
+ Attributes::MinCoolSetpointLimit::TypeInfo::DecodableType minCoolSetpointLimit = static_cast<int16_t>(0);
+ Attributes::MaxCoolSetpointLimit::TypeInfo::DecodableType maxCoolSetpointLimit = static_cast<int16_t>(0);
+ Attributes::MinSetpointDeadBand::TypeInfo::DecodableType minSetpointDeadBand = static_cast<int8_t>(0);
+ Attributes::RemoteSensing::TypeInfo::DecodableType remoteSensing =
+ static_cast<chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>>(0);
+ Attributes::ControlSequenceOfOperation::TypeInfo::DecodableType controlSequenceOfOperation =
+ static_cast<chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum>(0);
+ Attributes::SystemMode::TypeInfo::DecodableType systemMode =
+ static_cast<chip::app::Clusters::Thermostat::SystemModeEnum>(0);
+ Attributes::ThermostatRunningMode::TypeInfo::DecodableType thermostatRunningMode =
+ static_cast<chip::app::Clusters::Thermostat::ThermostatRunningModeEnum>(0);
+ Attributes::StartOfWeek::TypeInfo::DecodableType startOfWeek =
+ static_cast<chip::app::Clusters::Thermostat::StartOfWeekEnum>(0);
+ Attributes::NumberOfWeeklyTransitions::TypeInfo::DecodableType numberOfWeeklyTransitions = static_cast<uint8_t>(0);
+ Attributes::NumberOfDailyTransitions::TypeInfo::DecodableType numberOfDailyTransitions = static_cast<uint8_t>(0);
+ Attributes::TemperatureSetpointHold::TypeInfo::DecodableType temperatureSetpointHold =
+ static_cast<chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum>(0);
+ Attributes::TemperatureSetpointHoldDuration::TypeInfo::DecodableType temperatureSetpointHoldDuration;
+ Attributes::ThermostatProgrammingOperationMode::TypeInfo::DecodableType thermostatProgrammingOperationMode =
+ static_cast<chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>>(0);
+ Attributes::ThermostatRunningState::TypeInfo::DecodableType thermostatRunningState =
+ static_cast<chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>>(0);
+ Attributes::SetpointChangeSource::TypeInfo::DecodableType setpointChangeSource =
+ static_cast<chip::app::Clusters::Thermostat::SetpointChangeSourceEnum>(0);
+ Attributes::SetpointChangeAmount::TypeInfo::DecodableType setpointChangeAmount;
+ Attributes::SetpointChangeSourceTimestamp::TypeInfo::DecodableType setpointChangeSourceTimestamp = static_cast<uint32_t>(0);
+ Attributes::OccupiedSetback::TypeInfo::DecodableType occupiedSetback;
+ Attributes::OccupiedSetbackMin::TypeInfo::DecodableType occupiedSetbackMin;
+ Attributes::OccupiedSetbackMax::TypeInfo::DecodableType occupiedSetbackMax;
+ Attributes::UnoccupiedSetback::TypeInfo::DecodableType unoccupiedSetback;
+ Attributes::UnoccupiedSetbackMin::TypeInfo::DecodableType unoccupiedSetbackMin;
+ Attributes::UnoccupiedSetbackMax::TypeInfo::DecodableType unoccupiedSetbackMax;
+ Attributes::EmergencyHeatDelta::TypeInfo::DecodableType emergencyHeatDelta = static_cast<uint8_t>(0);
+ Attributes::ACType::TypeInfo::DecodableType ACType = static_cast<chip::app::Clusters::Thermostat::ACTypeEnum>(0);
+ Attributes::ACCapacity::TypeInfo::DecodableType ACCapacity = static_cast<uint16_t>(0);
+ Attributes::ACRefrigerantType::TypeInfo::DecodableType ACRefrigerantType =
+ static_cast<chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum>(0);
+ Attributes::ACCompressorType::TypeInfo::DecodableType ACCompressorType =
+ static_cast<chip::app::Clusters::Thermostat::ACCompressorTypeEnum>(0);
+ Attributes::ACErrorCode::TypeInfo::DecodableType ACErrorCode =
+ static_cast<chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>>(0);
+ Attributes::ACLouverPosition::TypeInfo::DecodableType ACLouverPosition =
+ static_cast<chip::app::Clusters::Thermostat::ACLouverPositionEnum>(0);
+ Attributes::ACCoilTemperature::TypeInfo::DecodableType ACCoilTemperature;
+ Attributes::ACCapacityformat::TypeInfo::DecodableType ACCapacityformat =
+ static_cast<chip::app::Clusters::Thermostat::ACCapacityFormatEnum>(0);
+ Attributes::PresetTypes::TypeInfo::DecodableType presetTypes;
+ Attributes::ScheduleTypes::TypeInfo::DecodableType scheduleTypes;
+ Attributes::NumberOfPresets::TypeInfo::DecodableType numberOfPresets = static_cast<uint8_t>(0);
+ Attributes::NumberOfSchedules::TypeInfo::DecodableType numberOfSchedules = static_cast<uint8_t>(0);
+ Attributes::NumberOfScheduleTransitions::TypeInfo::DecodableType numberOfScheduleTransitions = static_cast<uint8_t>(0);
+ Attributes::NumberOfScheduleTransitionPerDay::TypeInfo::DecodableType numberOfScheduleTransitionPerDay;
+ Attributes::ActivePresetHandle::TypeInfo::DecodableType activePresetHandle;
+ Attributes::ActiveScheduleHandle::TypeInfo::DecodableType activeScheduleHandle;
+ Attributes::Presets::TypeInfo::DecodableType presets;
+ Attributes::Schedules::TypeInfo::DecodableType schedules;
+ Attributes::SetpointHoldExpiryTimestamp::TypeInfo::DecodableType setpointHoldExpiryTimestamp;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Thermostat
+namespace FanControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Step {
+struct Type;
+struct DecodableType;
+} // namespace Step
+
+} // namespace Commands
+
+namespace Commands {
+namespace Step {
+enum class Fields : uint8_t
+{
+ kDirection = 0,
+ kWrap = 1,
+ kLowestOff = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Step::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+
+ StepDirectionEnum direction = static_cast<StepDirectionEnum>(0);
+ Optional<bool> wrap;
+ Optional<bool> lowestOff;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Step::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+
+ StepDirectionEnum direction = static_cast<StepDirectionEnum>(0);
+ Optional<bool> wrap;
+ Optional<bool> lowestOff;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Step
+} // namespace Commands
+
+namespace Attributes {
+
+namespace FanMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::FanControl::FanModeEnum;
+ using DecodableType = chip::app::Clusters::FanControl::FanModeEnum;
+ using DecodableArgType = chip::app::Clusters::FanControl::FanModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FanMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FanMode
+namespace FanModeSequence {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::FanControl::FanModeSequenceEnum;
+ using DecodableType = chip::app::Clusters::FanControl::FanModeSequenceEnum;
+ using DecodableArgType = chip::app::Clusters::FanControl::FanModeSequenceEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FanModeSequence::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FanModeSequence
+namespace PercentSetting {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::Percent>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::Percent> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PercentSetting::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PercentSetting
+namespace PercentCurrent {
+struct TypeInfo
+{
+ using Type = chip::Percent;
+ using DecodableType = chip::Percent;
+ using DecodableArgType = chip::Percent;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PercentCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PercentCurrent
+namespace SpeedMax {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeedMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeedMax
+namespace SpeedSetting {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeedSetting::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeedSetting
+namespace SpeedCurrent {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeedCurrent::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeedCurrent
+namespace RockSupport {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RockSupport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RockSupport
+namespace RockSetting {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RockSetting::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RockSetting
+namespace WindSupport {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WindSupport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WindSupport
+namespace WindSetting {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WindSetting::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WindSetting
+namespace AirflowDirection {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::FanControl::AirflowDirectionEnum;
+ using DecodableType = chip::app::Clusters::FanControl::AirflowDirectionEnum;
+ using DecodableArgType = chip::app::Clusters::FanControl::AirflowDirectionEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AirflowDirection::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AirflowDirection
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::FanMode::TypeInfo::DecodableType fanMode = static_cast<chip::app::Clusters::FanControl::FanModeEnum>(0);
+ Attributes::FanModeSequence::TypeInfo::DecodableType fanModeSequence =
+ static_cast<chip::app::Clusters::FanControl::FanModeSequenceEnum>(0);
+ Attributes::PercentSetting::TypeInfo::DecodableType percentSetting;
+ Attributes::PercentCurrent::TypeInfo::DecodableType percentCurrent = static_cast<chip::Percent>(0);
+ Attributes::SpeedMax::TypeInfo::DecodableType speedMax = static_cast<uint8_t>(0);
+ Attributes::SpeedSetting::TypeInfo::DecodableType speedSetting;
+ Attributes::SpeedCurrent::TypeInfo::DecodableType speedCurrent = static_cast<uint8_t>(0);
+ Attributes::RockSupport::TypeInfo::DecodableType rockSupport =
+ static_cast<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>(0);
+ Attributes::RockSetting::TypeInfo::DecodableType rockSetting =
+ static_cast<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>(0);
+ Attributes::WindSupport::TypeInfo::DecodableType windSupport =
+ static_cast<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>(0);
+ Attributes::WindSetting::TypeInfo::DecodableType windSetting =
+ static_cast<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>(0);
+ Attributes::AirflowDirection::TypeInfo::DecodableType airflowDirection =
+ static_cast<chip::app::Clusters::FanControl::AirflowDirectionEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace FanControl
+namespace ThermostatUserInterfaceConfiguration {
+
+namespace Attributes {
+
+namespace TemperatureDisplayMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum;
+ using DecodableType = chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum;
+ using DecodableArgType = chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureDisplayMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TemperatureDisplayMode
+namespace KeypadLockout {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum;
+ using DecodableType = chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum;
+ using DecodableArgType = chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::KeypadLockout::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace KeypadLockout
+namespace ScheduleProgrammingVisibility {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum;
+ using DecodableType = chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum;
+ using DecodableArgType = chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScheduleProgrammingVisibility::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScheduleProgrammingVisibility
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::TemperatureDisplayMode::TypeInfo::DecodableType temperatureDisplayMode =
+ static_cast<chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum>(0);
+ Attributes::KeypadLockout::TypeInfo::DecodableType keypadLockout =
+ static_cast<chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum>(0);
+ Attributes::ScheduleProgrammingVisibility::TypeInfo::DecodableType scheduleProgrammingVisibility =
+ static_cast<chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ThermostatUserInterfaceConfiguration
+namespace ColorControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace MoveToHue {
+struct Type;
+struct DecodableType;
+} // namespace MoveToHue
+
+namespace MoveHue {
+struct Type;
+struct DecodableType;
+} // namespace MoveHue
+
+namespace StepHue {
+struct Type;
+struct DecodableType;
+} // namespace StepHue
+
+namespace MoveToSaturation {
+struct Type;
+struct DecodableType;
+} // namespace MoveToSaturation
+
+namespace MoveSaturation {
+struct Type;
+struct DecodableType;
+} // namespace MoveSaturation
+
+namespace StepSaturation {
+struct Type;
+struct DecodableType;
+} // namespace StepSaturation
+
+namespace MoveToHueAndSaturation {
+struct Type;
+struct DecodableType;
+} // namespace MoveToHueAndSaturation
+
+namespace MoveToColor {
+struct Type;
+struct DecodableType;
+} // namespace MoveToColor
+
+namespace MoveColor {
+struct Type;
+struct DecodableType;
+} // namespace MoveColor
+
+namespace StepColor {
+struct Type;
+struct DecodableType;
+} // namespace StepColor
+
+namespace MoveToColorTemperature {
+struct Type;
+struct DecodableType;
+} // namespace MoveToColorTemperature
+
+namespace EnhancedMoveToHue {
+struct Type;
+struct DecodableType;
+} // namespace EnhancedMoveToHue
+
+namespace EnhancedMoveHue {
+struct Type;
+struct DecodableType;
+} // namespace EnhancedMoveHue
+
+namespace EnhancedStepHue {
+struct Type;
+struct DecodableType;
+} // namespace EnhancedStepHue
+
+namespace EnhancedMoveToHueAndSaturation {
+struct Type;
+struct DecodableType;
+} // namespace EnhancedMoveToHueAndSaturation
+
+namespace ColorLoopSet {
+struct Type;
+struct DecodableType;
+} // namespace ColorLoopSet
+
+namespace StopMoveStep {
+struct Type;
+struct DecodableType;
+} // namespace StopMoveStep
+
+namespace MoveColorTemperature {
+struct Type;
+struct DecodableType;
+} // namespace MoveColorTemperature
+
+namespace StepColorTemperature {
+struct Type;
+struct DecodableType;
+} // namespace StepColorTemperature
+
+} // namespace Commands
+
+namespace Commands {
+namespace MoveToHue {
+enum class Fields : uint8_t
+{
+ kHue = 0,
+ kDirection = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint8_t hue = static_cast<uint8_t>(0);
+ DirectionEnum direction = static_cast<DirectionEnum>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint8_t hue = static_cast<uint8_t>(0);
+ DirectionEnum direction = static_cast<DirectionEnum>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToHue
+namespace MoveHue {
+enum class Fields : uint8_t
+{
+ kMoveMode = 0,
+ kRate = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint8_t rate = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint8_t rate = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveHue
+namespace StepHue {
+enum class Fields : uint8_t
+{
+ kStepMode = 0,
+ kStepSize = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StepHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ uint8_t transitionTime = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StepHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ uint8_t transitionTime = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepHue
+namespace MoveToSaturation {
+enum class Fields : uint8_t
+{
+ kSaturation = 0,
+ kTransitionTime = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint8_t saturation = static_cast<uint8_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint8_t saturation = static_cast<uint8_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToSaturation
+namespace MoveSaturation {
+enum class Fields : uint8_t
+{
+ kMoveMode = 0,
+ kRate = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint8_t rate = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint8_t rate = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveSaturation
+namespace StepSaturation {
+enum class Fields : uint8_t
+{
+ kStepMode = 0,
+ kStepSize = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StepSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ uint8_t transitionTime = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StepSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint8_t stepSize = static_cast<uint8_t>(0);
+ uint8_t transitionTime = static_cast<uint8_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepSaturation
+namespace MoveToHueAndSaturation {
+enum class Fields : uint8_t
+{
+ kHue = 0,
+ kSaturation = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToHueAndSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint8_t hue = static_cast<uint8_t>(0);
+ uint8_t saturation = static_cast<uint8_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToHueAndSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint8_t hue = static_cast<uint8_t>(0);
+ uint8_t saturation = static_cast<uint8_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToHueAndSaturation
+namespace MoveToColor {
+enum class Fields : uint8_t
+{
+ kColorX = 0,
+ kColorY = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToColor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t colorX = static_cast<uint16_t>(0);
+ uint16_t colorY = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToColor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t colorX = static_cast<uint16_t>(0);
+ uint16_t colorY = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToColor
+namespace MoveColor {
+enum class Fields : uint8_t
+{
+ kRateX = 0,
+ kRateY = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveColor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ int16_t rateX = static_cast<int16_t>(0);
+ int16_t rateY = static_cast<int16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveColor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ int16_t rateX = static_cast<int16_t>(0);
+ int16_t rateY = static_cast<int16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveColor
+namespace StepColor {
+enum class Fields : uint8_t
+{
+ kStepX = 0,
+ kStepY = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StepColor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ int16_t stepX = static_cast<int16_t>(0);
+ int16_t stepY = static_cast<int16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StepColor::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ int16_t stepX = static_cast<int16_t>(0);
+ int16_t stepY = static_cast<int16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepColor
+namespace MoveToColorTemperature {
+enum class Fields : uint8_t
+{
+ kColorTemperatureMireds = 0,
+ kTransitionTime = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveToColorTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t colorTemperatureMireds = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveToColorTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t colorTemperatureMireds = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveToColorTemperature
+namespace EnhancedMoveToHue {
+enum class Fields : uint8_t
+{
+ kEnhancedHue = 0,
+ kDirection = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedMoveToHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t enhancedHue = static_cast<uint16_t>(0);
+ DirectionEnum direction = static_cast<DirectionEnum>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedMoveToHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t enhancedHue = static_cast<uint16_t>(0);
+ DirectionEnum direction = static_cast<DirectionEnum>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedMoveToHue
+namespace EnhancedMoveHue {
+enum class Fields : uint8_t
+{
+ kMoveMode = 0,
+ kRate = 1,
+ kOptionsMask = 2,
+ kOptionsOverride = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedMoveHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint16_t rate = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedMoveHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint16_t rate = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedMoveHue
+namespace EnhancedStepHue {
+enum class Fields : uint8_t
+{
+ kStepMode = 0,
+ kStepSize = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedStepHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint16_t stepSize = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedStepHue::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint16_t stepSize = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedStepHue
+namespace EnhancedMoveToHueAndSaturation {
+enum class Fields : uint8_t
+{
+ kEnhancedHue = 0,
+ kSaturation = 1,
+ kTransitionTime = 2,
+ kOptionsMask = 3,
+ kOptionsOverride = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedMoveToHueAndSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t enhancedHue = static_cast<uint16_t>(0);
+ uint8_t saturation = static_cast<uint8_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EnhancedMoveToHueAndSaturation::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ uint16_t enhancedHue = static_cast<uint16_t>(0);
+ uint8_t saturation = static_cast<uint8_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EnhancedMoveToHueAndSaturation
+namespace ColorLoopSet {
+enum class Fields : uint8_t
+{
+ kUpdateFlags = 0,
+ kAction = 1,
+ kDirection = 2,
+ kTime = 3,
+ kStartHue = 4,
+ kOptionsMask = 5,
+ kOptionsOverride = 6,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ColorLoopSet::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ chip::BitMask<UpdateFlagsBitmap> updateFlags = static_cast<chip::BitMask<UpdateFlagsBitmap>>(0);
+ ColorLoopActionEnum action = static_cast<ColorLoopActionEnum>(0);
+ ColorLoopDirectionEnum direction = static_cast<ColorLoopDirectionEnum>(0);
+ uint16_t time = static_cast<uint16_t>(0);
+ uint16_t startHue = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ColorLoopSet::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ chip::BitMask<UpdateFlagsBitmap> updateFlags = static_cast<chip::BitMask<UpdateFlagsBitmap>>(0);
+ ColorLoopActionEnum action = static_cast<ColorLoopActionEnum>(0);
+ ColorLoopDirectionEnum direction = static_cast<ColorLoopDirectionEnum>(0);
+ uint16_t time = static_cast<uint16_t>(0);
+ uint16_t startHue = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ColorLoopSet
+namespace StopMoveStep {
+enum class Fields : uint8_t
+{
+ kOptionsMask = 0,
+ kOptionsOverride = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StopMoveStep::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StopMoveStep::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopMoveStep
+namespace MoveColorTemperature {
+enum class Fields : uint8_t
+{
+ kMoveMode = 0,
+ kRate = 1,
+ kColorTemperatureMinimumMireds = 2,
+ kColorTemperatureMaximumMireds = 3,
+ kOptionsMask = 4,
+ kOptionsOverride = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MoveColorTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint16_t rate = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MoveColorTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
+ uint16_t rate = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MoveColorTemperature
+namespace StepColorTemperature {
+enum class Fields : uint8_t
+{
+ kStepMode = 0,
+ kStepSize = 1,
+ kTransitionTime = 2,
+ kColorTemperatureMinimumMireds = 3,
+ kColorTemperatureMaximumMireds = 4,
+ kOptionsMask = 5,
+ kOptionsOverride = 6,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StepColorTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint16_t stepSize = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StepColorTemperature::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ StepModeEnum stepMode = static_cast<StepModeEnum>(0);
+ uint16_t stepSize = static_cast<uint16_t>(0);
+ uint16_t transitionTime = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
+ uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
+ chip::BitMask<OptionsBitmap> optionsMask = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ chip::BitMask<OptionsBitmap> optionsOverride = static_cast<chip::BitMask<OptionsBitmap>>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StepColorTemperature
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CurrentHue {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentHue
+namespace CurrentSaturation {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentSaturation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentSaturation
+namespace RemainingTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RemainingTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RemainingTime
+namespace CurrentX {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentX::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentX
+namespace CurrentY {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentY::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentY
+namespace DriftCompensation {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ColorControl::DriftCompensationEnum;
+ using DecodableType = chip::app::Clusters::ColorControl::DriftCompensationEnum;
+ using DecodableArgType = chip::app::Clusters::ColorControl::DriftCompensationEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DriftCompensation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DriftCompensation
+namespace CompensationText {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CompensationText::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 254; }
+};
+} // namespace CompensationText
+namespace ColorTemperatureMireds {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorTemperatureMireds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorTemperatureMireds
+namespace ColorMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ColorControl::ColorModeEnum;
+ using DecodableType = chip::app::Clusters::ColorControl::ColorModeEnum;
+ using DecodableArgType = chip::app::Clusters::ColorControl::ColorModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorMode
+namespace Options {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Options::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Options
+namespace NumberOfPrimaries {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPrimaries::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NumberOfPrimaries
+namespace Primary1X {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary1X::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary1X
+namespace Primary1Y {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary1Y::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary1Y
+namespace Primary1Intensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary1Intensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary1Intensity
+namespace Primary2X {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary2X::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary2X
+namespace Primary2Y {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary2Y::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary2Y
+namespace Primary2Intensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary2Intensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary2Intensity
+namespace Primary3X {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary3X::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary3X
+namespace Primary3Y {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary3Y::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary3Y
+namespace Primary3Intensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary3Intensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary3Intensity
+namespace Primary4X {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary4X::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary4X
+namespace Primary4Y {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary4Y::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary4Y
+namespace Primary4Intensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary4Intensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary4Intensity
+namespace Primary5X {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary5X::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary5X
+namespace Primary5Y {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary5Y::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary5Y
+namespace Primary5Intensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary5Intensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary5Intensity
+namespace Primary6X {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary6X::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary6X
+namespace Primary6Y {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary6Y::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary6Y
+namespace Primary6Intensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Primary6Intensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Primary6Intensity
+namespace WhitePointX {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WhitePointX::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WhitePointX
+namespace WhitePointY {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WhitePointY::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WhitePointY
+namespace ColorPointRX {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointRX::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointRX
+namespace ColorPointRY {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointRY::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointRY
+namespace ColorPointRIntensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointRIntensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointRIntensity
+namespace ColorPointGX {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointGX::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointGX
+namespace ColorPointGY {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointGY::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointGY
+namespace ColorPointGIntensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointGIntensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointGIntensity
+namespace ColorPointBX {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointBX::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointBX
+namespace ColorPointBY {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointBY::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointBY
+namespace ColorPointBIntensity {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorPointBIntensity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorPointBIntensity
+namespace EnhancedCurrentHue {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnhancedCurrentHue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnhancedCurrentHue
+namespace EnhancedColorMode {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ColorControl::EnhancedColorModeEnum;
+ using DecodableType = chip::app::Clusters::ColorControl::EnhancedColorModeEnum;
+ using DecodableArgType = chip::app::Clusters::ColorControl::EnhancedColorModeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnhancedColorMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnhancedColorMode
+namespace ColorLoopActive {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopActive::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorLoopActive
+namespace ColorLoopDirection {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopDirection::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorLoopDirection
+namespace ColorLoopTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorLoopTime
+namespace ColorLoopStartEnhancedHue {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopStartEnhancedHue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorLoopStartEnhancedHue
+namespace ColorLoopStoredEnhancedHue {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorLoopStoredEnhancedHue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorLoopStoredEnhancedHue
+namespace ColorCapabilities {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorCapabilities::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorCapabilities
+namespace ColorTempPhysicalMinMireds {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorTempPhysicalMinMireds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorTempPhysicalMinMireds
+namespace ColorTempPhysicalMaxMireds {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ColorTempPhysicalMaxMireds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ColorTempPhysicalMaxMireds
+namespace CoupleColorTempToLevelMinMireds {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CoupleColorTempToLevelMinMireds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CoupleColorTempToLevelMinMireds
+namespace StartUpColorTemperatureMireds {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartUpColorTemperatureMireds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartUpColorTemperatureMireds
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CurrentHue::TypeInfo::DecodableType currentHue = static_cast<uint8_t>(0);
+ Attributes::CurrentSaturation::TypeInfo::DecodableType currentSaturation = static_cast<uint8_t>(0);
+ Attributes::RemainingTime::TypeInfo::DecodableType remainingTime = static_cast<uint16_t>(0);
+ Attributes::CurrentX::TypeInfo::DecodableType currentX = static_cast<uint16_t>(0);
+ Attributes::CurrentY::TypeInfo::DecodableType currentY = static_cast<uint16_t>(0);
+ Attributes::DriftCompensation::TypeInfo::DecodableType driftCompensation =
+ static_cast<chip::app::Clusters::ColorControl::DriftCompensationEnum>(0);
+ Attributes::CompensationText::TypeInfo::DecodableType compensationText;
+ Attributes::ColorTemperatureMireds::TypeInfo::DecodableType colorTemperatureMireds = static_cast<uint16_t>(0);
+ Attributes::ColorMode::TypeInfo::DecodableType colorMode = static_cast<chip::app::Clusters::ColorControl::ColorModeEnum>(0);
+ Attributes::Options::TypeInfo::DecodableType options =
+ static_cast<chip::BitMask<chip::app::Clusters::ColorControl::OptionsBitmap>>(0);
+ Attributes::NumberOfPrimaries::TypeInfo::DecodableType numberOfPrimaries;
+ Attributes::Primary1X::TypeInfo::DecodableType primary1X = static_cast<uint16_t>(0);
+ Attributes::Primary1Y::TypeInfo::DecodableType primary1Y = static_cast<uint16_t>(0);
+ Attributes::Primary1Intensity::TypeInfo::DecodableType primary1Intensity;
+ Attributes::Primary2X::TypeInfo::DecodableType primary2X = static_cast<uint16_t>(0);
+ Attributes::Primary2Y::TypeInfo::DecodableType primary2Y = static_cast<uint16_t>(0);
+ Attributes::Primary2Intensity::TypeInfo::DecodableType primary2Intensity;
+ Attributes::Primary3X::TypeInfo::DecodableType primary3X = static_cast<uint16_t>(0);
+ Attributes::Primary3Y::TypeInfo::DecodableType primary3Y = static_cast<uint16_t>(0);
+ Attributes::Primary3Intensity::TypeInfo::DecodableType primary3Intensity;
+ Attributes::Primary4X::TypeInfo::DecodableType primary4X = static_cast<uint16_t>(0);
+ Attributes::Primary4Y::TypeInfo::DecodableType primary4Y = static_cast<uint16_t>(0);
+ Attributes::Primary4Intensity::TypeInfo::DecodableType primary4Intensity;
+ Attributes::Primary5X::TypeInfo::DecodableType primary5X = static_cast<uint16_t>(0);
+ Attributes::Primary5Y::TypeInfo::DecodableType primary5Y = static_cast<uint16_t>(0);
+ Attributes::Primary5Intensity::TypeInfo::DecodableType primary5Intensity;
+ Attributes::Primary6X::TypeInfo::DecodableType primary6X = static_cast<uint16_t>(0);
+ Attributes::Primary6Y::TypeInfo::DecodableType primary6Y = static_cast<uint16_t>(0);
+ Attributes::Primary6Intensity::TypeInfo::DecodableType primary6Intensity;
+ Attributes::WhitePointX::TypeInfo::DecodableType whitePointX = static_cast<uint16_t>(0);
+ Attributes::WhitePointY::TypeInfo::DecodableType whitePointY = static_cast<uint16_t>(0);
+ Attributes::ColorPointRX::TypeInfo::DecodableType colorPointRX = static_cast<uint16_t>(0);
+ Attributes::ColorPointRY::TypeInfo::DecodableType colorPointRY = static_cast<uint16_t>(0);
+ Attributes::ColorPointRIntensity::TypeInfo::DecodableType colorPointRIntensity;
+ Attributes::ColorPointGX::TypeInfo::DecodableType colorPointGX = static_cast<uint16_t>(0);
+ Attributes::ColorPointGY::TypeInfo::DecodableType colorPointGY = static_cast<uint16_t>(0);
+ Attributes::ColorPointGIntensity::TypeInfo::DecodableType colorPointGIntensity;
+ Attributes::ColorPointBX::TypeInfo::DecodableType colorPointBX = static_cast<uint16_t>(0);
+ Attributes::ColorPointBY::TypeInfo::DecodableType colorPointBY = static_cast<uint16_t>(0);
+ Attributes::ColorPointBIntensity::TypeInfo::DecodableType colorPointBIntensity;
+ Attributes::EnhancedCurrentHue::TypeInfo::DecodableType enhancedCurrentHue = static_cast<uint16_t>(0);
+ Attributes::EnhancedColorMode::TypeInfo::DecodableType enhancedColorMode =
+ static_cast<chip::app::Clusters::ColorControl::EnhancedColorModeEnum>(0);
+ Attributes::ColorLoopActive::TypeInfo::DecodableType colorLoopActive = static_cast<uint8_t>(0);
+ Attributes::ColorLoopDirection::TypeInfo::DecodableType colorLoopDirection = static_cast<uint8_t>(0);
+ Attributes::ColorLoopTime::TypeInfo::DecodableType colorLoopTime = static_cast<uint16_t>(0);
+ Attributes::ColorLoopStartEnhancedHue::TypeInfo::DecodableType colorLoopStartEnhancedHue = static_cast<uint16_t>(0);
+ Attributes::ColorLoopStoredEnhancedHue::TypeInfo::DecodableType colorLoopStoredEnhancedHue = static_cast<uint16_t>(0);
+ Attributes::ColorCapabilities::TypeInfo::DecodableType colorCapabilities =
+ static_cast<chip::BitMask<chip::app::Clusters::ColorControl::ColorCapabilitiesBitmap>>(0);
+ Attributes::ColorTempPhysicalMinMireds::TypeInfo::DecodableType colorTempPhysicalMinMireds = static_cast<uint16_t>(0);
+ Attributes::ColorTempPhysicalMaxMireds::TypeInfo::DecodableType colorTempPhysicalMaxMireds = static_cast<uint16_t>(0);
+ Attributes::CoupleColorTempToLevelMinMireds::TypeInfo::DecodableType coupleColorTempToLevelMinMireds =
+ static_cast<uint16_t>(0);
+ Attributes::StartUpColorTemperatureMireds::TypeInfo::DecodableType startUpColorTemperatureMireds;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ColorControl
+namespace BallastConfiguration {
+
+namespace Attributes {
+
+namespace PhysicalMinLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalMinLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalMinLevel
+namespace PhysicalMaxLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalMaxLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalMaxLevel
+namespace BallastStatus {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BallastStatus::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BallastStatus
+namespace MinLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinLevel
+namespace MaxLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxLevel
+namespace IntrinsicBallastFactor {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::IntrinsicBallastFactor::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace IntrinsicBallastFactor
+namespace BallastFactorAdjustment {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BallastFactorAdjustment::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BallastFactorAdjustment
+namespace LampQuantity {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampQuantity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LampQuantity
+namespace LampType {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace LampType
+namespace LampManufacturer {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampManufacturer::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace LampManufacturer
+namespace LampRatedHours {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampRatedHours::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LampRatedHours
+namespace LampBurnHours {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampBurnHours::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LampBurnHours
+namespace LampAlarmMode {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampAlarmMode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LampAlarmMode
+namespace LampBurnHoursTripPoint {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LampBurnHoursTripPoint::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LampBurnHoursTripPoint
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PhysicalMinLevel::TypeInfo::DecodableType physicalMinLevel = static_cast<uint8_t>(0);
+ Attributes::PhysicalMaxLevel::TypeInfo::DecodableType physicalMaxLevel = static_cast<uint8_t>(0);
+ Attributes::BallastStatus::TypeInfo::DecodableType ballastStatus =
+ static_cast<chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>>(0);
+ Attributes::MinLevel::TypeInfo::DecodableType minLevel = static_cast<uint8_t>(0);
+ Attributes::MaxLevel::TypeInfo::DecodableType maxLevel = static_cast<uint8_t>(0);
+ Attributes::IntrinsicBallastFactor::TypeInfo::DecodableType intrinsicBallastFactor;
+ Attributes::BallastFactorAdjustment::TypeInfo::DecodableType ballastFactorAdjustment;
+ Attributes::LampQuantity::TypeInfo::DecodableType lampQuantity = static_cast<uint8_t>(0);
+ Attributes::LampType::TypeInfo::DecodableType lampType;
+ Attributes::LampManufacturer::TypeInfo::DecodableType lampManufacturer;
+ Attributes::LampRatedHours::TypeInfo::DecodableType lampRatedHours;
+ Attributes::LampBurnHours::TypeInfo::DecodableType lampBurnHours;
+ Attributes::LampAlarmMode::TypeInfo::DecodableType lampAlarmMode =
+ static_cast<chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>>(0);
+ Attributes::LampBurnHoursTripPoint::TypeInfo::DecodableType lampBurnHoursTripPoint;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace BallastConfiguration
+namespace IlluminanceMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Tolerance
+namespace LightSensorType {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LightSensorType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LightSensorType
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::Tolerance::TypeInfo::DecodableType tolerance = static_cast<uint16_t>(0);
+ Attributes::LightSensorType::TypeInfo::DecodableType lightSensorType;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace IlluminanceMeasurement
+namespace TemperatureMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Tolerance
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::Tolerance::TypeInfo::DecodableType tolerance = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace TemperatureMeasurement
+namespace PressureMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Tolerance
+namespace ScaledValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScaledValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScaledValue
+namespace MinScaledValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinScaledValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinScaledValue
+namespace MaxScaledValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxScaledValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxScaledValue
+namespace ScaledTolerance {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScaledTolerance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScaledTolerance
+namespace Scale {
+struct TypeInfo
+{
+ using Type = int8_t;
+ using DecodableType = int8_t;
+ using DecodableArgType = int8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Scale::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Scale
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::Tolerance::TypeInfo::DecodableType tolerance = static_cast<uint16_t>(0);
+ Attributes::ScaledValue::TypeInfo::DecodableType scaledValue;
+ Attributes::MinScaledValue::TypeInfo::DecodableType minScaledValue;
+ Attributes::MaxScaledValue::TypeInfo::DecodableType maxScaledValue;
+ Attributes::ScaledTolerance::TypeInfo::DecodableType scaledTolerance = static_cast<uint16_t>(0);
+ Attributes::Scale::TypeInfo::DecodableType scale = static_cast<int8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace PressureMeasurement
+namespace FlowMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Tolerance
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::Tolerance::TypeInfo::DecodableType tolerance = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace FlowMeasurement
+namespace RelativeHumidityMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace Tolerance {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Tolerance::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Tolerance
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::Tolerance::TypeInfo::DecodableType tolerance = static_cast<uint16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace RelativeHumidityMeasurement
+namespace OccupancySensing {
+namespace Structs {
+namespace HoldTimeLimitsStruct {
+enum class Fields : uint8_t
+{
+ kHoldTimeMin = 0,
+ kHoldTimeMax = 1,
+ kHoldTimeDefault = 2,
+};
+
+struct Type
+{
+public:
+ uint16_t holdTimeMin = static_cast<uint16_t>(0);
+ uint16_t holdTimeMax = static_cast<uint16_t>(0);
+ uint16_t holdTimeDefault = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace HoldTimeLimitsStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace Occupancy {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Occupancy::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Occupancy
+namespace OccupancySensorType {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum;
+ using DecodableType = chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum;
+ using DecodableArgType = chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupancySensorType::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupancySensorType
+namespace OccupancySensorTypeBitmap {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OccupancySensorTypeBitmap::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OccupancySensorTypeBitmap
+namespace HoldTime {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HoldTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HoldTime
+namespace HoldTimeLimits {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OccupancySensing::Structs::HoldTimeLimitsStruct::Type;
+ using DecodableType = chip::app::Clusters::OccupancySensing::Structs::HoldTimeLimitsStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::OccupancySensing::Structs::HoldTimeLimitsStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HoldTimeLimits::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HoldTimeLimits
+namespace PIROccupiedToUnoccupiedDelay {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PIROccupiedToUnoccupiedDelay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PIROccupiedToUnoccupiedDelay
+namespace PIRUnoccupiedToOccupiedDelay {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PIRUnoccupiedToOccupiedDelay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PIRUnoccupiedToOccupiedDelay
+namespace PIRUnoccupiedToOccupiedThreshold {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PIRUnoccupiedToOccupiedThreshold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PIRUnoccupiedToOccupiedThreshold
+namespace UltrasonicOccupiedToUnoccupiedDelay {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UltrasonicOccupiedToUnoccupiedDelay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UltrasonicOccupiedToUnoccupiedDelay
+namespace UltrasonicUnoccupiedToOccupiedDelay {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UltrasonicUnoccupiedToOccupiedDelay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UltrasonicUnoccupiedToOccupiedDelay
+namespace UltrasonicUnoccupiedToOccupiedThreshold {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::UltrasonicUnoccupiedToOccupiedThreshold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace UltrasonicUnoccupiedToOccupiedThreshold
+namespace PhysicalContactOccupiedToUnoccupiedDelay {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalContactOccupiedToUnoccupiedDelay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalContactOccupiedToUnoccupiedDelay
+namespace PhysicalContactUnoccupiedToOccupiedDelay {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalContactUnoccupiedToOccupiedDelay::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalContactUnoccupiedToOccupiedDelay
+namespace PhysicalContactUnoccupiedToOccupiedThreshold {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PhysicalContactUnoccupiedToOccupiedThreshold
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Occupancy::TypeInfo::DecodableType occupancy =
+ static_cast<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>>(0);
+ Attributes::OccupancySensorType::TypeInfo::DecodableType occupancySensorType =
+ static_cast<chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum>(0);
+ Attributes::OccupancySensorTypeBitmap::TypeInfo::DecodableType occupancySensorTypeBitmap =
+ static_cast<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>>(0);
+ Attributes::HoldTime::TypeInfo::DecodableType holdTime = static_cast<uint16_t>(0);
+ Attributes::HoldTimeLimits::TypeInfo::DecodableType holdTimeLimits;
+ Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo::DecodableType PIROccupiedToUnoccupiedDelay = static_cast<uint16_t>(0);
+ Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo::DecodableType PIRUnoccupiedToOccupiedDelay = static_cast<uint16_t>(0);
+ Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo::DecodableType PIRUnoccupiedToOccupiedThreshold =
+ static_cast<uint8_t>(0);
+ Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo::DecodableType ultrasonicOccupiedToUnoccupiedDelay =
+ static_cast<uint16_t>(0);
+ Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo::DecodableType ultrasonicUnoccupiedToOccupiedDelay =
+ static_cast<uint16_t>(0);
+ Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo::DecodableType ultrasonicUnoccupiedToOccupiedThreshold =
+ static_cast<uint8_t>(0);
+ Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo::DecodableType physicalContactOccupiedToUnoccupiedDelay =
+ static_cast<uint16_t>(0);
+ Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo::DecodableType physicalContactUnoccupiedToOccupiedDelay =
+ static_cast<uint16_t>(0);
+ Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo::DecodableType
+ physicalContactUnoccupiedToOccupiedThreshold = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace OccupancyChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kOccupancy = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OccupancyChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<OccupancyBitmap> occupancy = static_cast<chip::BitMask<OccupancyBitmap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::OccupancyChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; }
+
+ chip::BitMask<OccupancyBitmap> occupancy = static_cast<chip::BitMask<OccupancyBitmap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace OccupancyChanged
+} // namespace Events
+} // namespace OccupancySensing
+namespace CarbonMonoxideConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace CarbonMonoxideConcentrationMeasurement
+namespace CarbonDioxideConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::CarbonDioxideConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::CarbonDioxideConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace CarbonDioxideConcentrationMeasurement
+namespace NitrogenDioxideConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace NitrogenDioxideConcentrationMeasurement
+namespace OzoneConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::OzoneConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::OzoneConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::OzoneConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::OzoneConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace OzoneConcentrationMeasurement
+namespace Pm25ConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm25ConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::Pm25ConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::Pm25ConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm25ConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::Pm25ConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Pm25ConcentrationMeasurement
+namespace FormaldehydeConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::FormaldehydeConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::FormaldehydeConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::FormaldehydeConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::FormaldehydeConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::FormaldehydeConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace FormaldehydeConcentrationMeasurement
+namespace Pm1ConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm1ConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::Pm1ConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::Pm1ConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm1ConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::Pm1ConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Pm1ConcentrationMeasurement
+namespace Pm10ConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Pm10ConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::Pm10ConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::Pm10ConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Pm10ConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::Pm10ConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Pm10ConcentrationMeasurement
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+namespace RadonConcentrationMeasurement {
+
+namespace Attributes {
+
+namespace MeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasuredValue
+namespace MinMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinMeasuredValue
+namespace MaxMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxMeasuredValue
+namespace PeakMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValue
+namespace PeakMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PeakMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PeakMeasuredValueWindow
+namespace AverageMeasuredValue {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValue
+namespace AverageMeasuredValueWindow {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AverageMeasuredValueWindow::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AverageMeasuredValueWindow
+namespace Uncertainty {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Uncertainty::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Uncertainty
+namespace MeasurementUnit {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::RadonConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableType = chip::app::Clusters::RadonConcentrationMeasurement::MeasurementUnitEnum;
+ using DecodableArgType = chip::app::Clusters::RadonConcentrationMeasurement::MeasurementUnitEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementUnit::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementUnit
+namespace MeasurementMedium {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::RadonConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableType = chip::app::Clusters::RadonConcentrationMeasurement::MeasurementMediumEnum;
+ using DecodableArgType = chip::app::Clusters::RadonConcentrationMeasurement::MeasurementMediumEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeasurementMedium::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeasurementMedium
+namespace LevelValue {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::RadonConcentrationMeasurement::LevelValueEnum;
+ using DecodableType = chip::app::Clusters::RadonConcentrationMeasurement::LevelValueEnum;
+ using DecodableArgType = chip::app::Clusters::RadonConcentrationMeasurement::LevelValueEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LevelValue::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LevelValue
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RadonConcentrationMeasurement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue;
+ Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue;
+ Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue;
+ Attributes::PeakMeasuredValue::TypeInfo::DecodableType peakMeasuredValue;
+ Attributes::PeakMeasuredValueWindow::TypeInfo::DecodableType peakMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::AverageMeasuredValue::TypeInfo::DecodableType averageMeasuredValue;
+ Attributes::AverageMeasuredValueWindow::TypeInfo::DecodableType averageMeasuredValueWindow = static_cast<uint32_t>(0);
+ Attributes::Uncertainty::TypeInfo::DecodableType uncertainty = static_cast<float>(0);
+ Attributes::MeasurementUnit::TypeInfo::DecodableType measurementUnit =
+ static_cast<chip::app::Clusters::RadonConcentrationMeasurement::MeasurementUnitEnum>(0);
+ Attributes::MeasurementMedium::TypeInfo::DecodableType measurementMedium =
+ static_cast<chip::app::Clusters::RadonConcentrationMeasurement::MeasurementMediumEnum>(0);
+ Attributes::LevelValue::TypeInfo::DecodableType levelValue =
+ static_cast<chip::app::Clusters::RadonConcentrationMeasurement::LevelValueEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace RadonConcentrationMeasurement
+namespace WiFiNetworkManagement {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace NetworkPassphraseRequest {
+struct Type;
+struct DecodableType;
+} // namespace NetworkPassphraseRequest
+
+namespace NetworkPassphraseResponse {
+struct Type;
+struct DecodableType;
+} // namespace NetworkPassphraseResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace NetworkPassphraseRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NetworkPassphraseRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::WiFiNetworkManagement::Commands::NetworkPassphraseResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NetworkPassphraseRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NetworkPassphraseRequest
+namespace NetworkPassphraseResponse {
+enum class Fields : uint8_t
+{
+ kPassphrase = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NetworkPassphraseResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+
+ chip::ByteSpan passphrase;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NetworkPassphraseResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+
+ chip::ByteSpan passphrase;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NetworkPassphraseResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Ssid {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Ssid::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace Ssid
+namespace PassphraseSurrogate {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PassphraseSurrogate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PassphraseSurrogate
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Ssid::TypeInfo::DecodableType ssid;
+ Attributes::PassphraseSurrogate::TypeInfo::DecodableType passphraseSurrogate;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace WiFiNetworkManagement
+namespace ThreadBorderRouterManagement {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace GetActiveDatasetRequest {
+struct Type;
+struct DecodableType;
+} // namespace GetActiveDatasetRequest
+
+namespace GetPendingDatasetRequest {
+struct Type;
+struct DecodableType;
+} // namespace GetPendingDatasetRequest
+
+namespace DatasetResponse {
+struct Type;
+struct DecodableType;
+} // namespace DatasetResponse
+
+namespace SetActiveDatasetRequest {
+struct Type;
+struct DecodableType;
+} // namespace SetActiveDatasetRequest
+
+namespace SetPendingDatasetRequest {
+struct Type;
+struct DecodableType;
+} // namespace SetPendingDatasetRequest
+
+} // namespace Commands
+
+namespace Commands {
+namespace GetActiveDatasetRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetActiveDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetActiveDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetActiveDatasetRequest
+namespace GetPendingDatasetRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetPendingDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetPendingDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetPendingDatasetRequest
+namespace DatasetResponse {
+enum class Fields : uint8_t
+{
+ kDataset = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DatasetResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ chip::ByteSpan dataset;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DatasetResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ chip::ByteSpan dataset;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DatasetResponse
+namespace SetActiveDatasetRequest {
+enum class Fields : uint8_t
+{
+ kActiveDataset = 0,
+ kBreadcrumb = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetActiveDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ chip::ByteSpan activeDataset;
+ Optional<uint64_t> breadcrumb;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetActiveDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ chip::ByteSpan activeDataset;
+ Optional<uint64_t> breadcrumb;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetActiveDatasetRequest
+namespace SetPendingDatasetRequest {
+enum class Fields : uint8_t
+{
+ kPendingDataset = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetPendingDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ chip::ByteSpan pendingDataset;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetPendingDatasetRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ chip::ByteSpan pendingDataset;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetPendingDatasetRequest
+} // namespace Commands
+
+namespace Attributes {
+
+namespace BorderRouterName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BorderRouterName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 63; }
+};
+} // namespace BorderRouterName
+namespace BorderAgentID {
+struct TypeInfo
+{
+ using Type = chip::ByteSpan;
+ using DecodableType = chip::ByteSpan;
+ using DecodableArgType = chip::ByteSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BorderAgentID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 254; }
+};
+} // namespace BorderAgentID
+namespace ThreadVersion {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThreadVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThreadVersion
+namespace InterfaceEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InterfaceEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InterfaceEnabled
+namespace ActiveDatasetTimestamp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveDatasetTimestamp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveDatasetTimestamp
+namespace PendingDatasetTimestamp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PendingDatasetTimestamp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PendingDatasetTimestamp
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::BorderRouterName::TypeInfo::DecodableType borderRouterName;
+ Attributes::BorderAgentID::TypeInfo::DecodableType borderAgentID;
+ Attributes::ThreadVersion::TypeInfo::DecodableType threadVersion = static_cast<uint16_t>(0);
+ Attributes::InterfaceEnabled::TypeInfo::DecodableType interfaceEnabled = static_cast<bool>(0);
+ Attributes::ActiveDatasetTimestamp::TypeInfo::DecodableType activeDatasetTimestamp;
+ Attributes::PendingDatasetTimestamp::TypeInfo::DecodableType pendingDatasetTimestamp;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ThreadBorderRouterManagement
+namespace ThreadNetworkDirectory {
+namespace Structs {
+namespace ThreadNetworkStruct {
+enum class Fields : uint8_t
+{
+ kExtendedPanID = 0,
+ kNetworkName = 1,
+ kChannel = 2,
+ kActiveTimestamp = 3,
+};
+
+struct Type
+{
+public:
+ chip::ByteSpan extendedPanID;
+ chip::CharSpan networkName;
+ uint16_t channel = static_cast<uint16_t>(0);
+ uint64_t activeTimestamp = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ThreadNetworkStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace AddNetwork {
+struct Type;
+struct DecodableType;
+} // namespace AddNetwork
+
+namespace RemoveNetwork {
+struct Type;
+struct DecodableType;
+} // namespace RemoveNetwork
+
+namespace GetOperationalDataset {
+struct Type;
+struct DecodableType;
+} // namespace GetOperationalDataset
+
+namespace OperationalDatasetResponse {
+struct Type;
+struct DecodableType;
+} // namespace OperationalDatasetResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace AddNetwork {
+enum class Fields : uint8_t
+{
+ kOperationalDataset = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan operationalDataset;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan operationalDataset;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddNetwork
+namespace RemoveNetwork {
+enum class Fields : uint8_t
+{
+ kExtendedPanID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan extendedPanID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveNetwork::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan extendedPanID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveNetwork
+namespace GetOperationalDataset {
+enum class Fields : uint8_t
+{
+ kExtendedPanID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetOperationalDataset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan extendedPanID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ThreadNetworkDirectory::Commands::OperationalDatasetResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetOperationalDataset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan extendedPanID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetOperationalDataset
+namespace OperationalDatasetResponse {
+enum class Fields : uint8_t
+{
+ kOperationalDataset = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::OperationalDatasetResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan operationalDataset;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::OperationalDatasetResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ chip::ByteSpan operationalDataset;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace OperationalDatasetResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace PreferredExtendedPanID {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PreferredExtendedPanID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 8; }
+};
+} // namespace PreferredExtendedPanID
+namespace ThreadNetworks {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDirectory::Structs::ThreadNetworkStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ThreadNetworkDirectory::Structs::ThreadNetworkStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ThreadNetworkDirectory::Structs::ThreadNetworkStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThreadNetworks::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThreadNetworks
+namespace ThreadNetworkTableSize {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ThreadNetworkTableSize::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ThreadNetworkTableSize
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDirectory::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::PreferredExtendedPanID::TypeInfo::DecodableType preferredExtendedPanID;
+ Attributes::ThreadNetworks::TypeInfo::DecodableType threadNetworks;
+ Attributes::ThreadNetworkTableSize::TypeInfo::DecodableType threadNetworkTableSize = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ThreadNetworkDirectory
+namespace WakeOnLan {
+
+namespace Attributes {
+
+namespace MACAddress {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MACAddress::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 12; }
+};
+} // namespace MACAddress
+namespace LinkLocalAddress {
+struct TypeInfo
+{
+ using Type = chip::ByteSpan;
+ using DecodableType = chip::ByteSpan;
+ using DecodableArgType = chip::ByteSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LinkLocalAddress::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 16; }
+};
+} // namespace LinkLocalAddress
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MACAddress::TypeInfo::DecodableType MACAddress;
+ Attributes::LinkLocalAddress::TypeInfo::DecodableType linkLocalAddress;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace WakeOnLan
+namespace Channel {
+namespace Structs {
+namespace ProgramCastStruct {
+enum class Fields : uint8_t
+{
+ kName = 0,
+ kRole = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan name;
+ chip::CharSpan role;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ProgramCastStruct
+namespace ProgramCategoryStruct {
+enum class Fields : uint8_t
+{
+ kCategory = 0,
+ kSubCategory = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan category;
+ Optional<chip::CharSpan> subCategory;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ProgramCategoryStruct
+namespace SeriesInfoStruct {
+enum class Fields : uint8_t
+{
+ kSeason = 0,
+ kEpisode = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan season;
+ chip::CharSpan episode;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SeriesInfoStruct
+namespace ChannelInfoStruct {
+enum class Fields : uint8_t
+{
+ kMajorNumber = 0,
+ kMinorNumber = 1,
+ kName = 2,
+ kCallSign = 3,
+ kAffiliateCallSign = 4,
+ kIdentifier = 5,
+ kType = 6,
+};
+
+struct Type
+{
+public:
+ uint16_t majorNumber = static_cast<uint16_t>(0);
+ uint16_t minorNumber = static_cast<uint16_t>(0);
+ Optional<chip::CharSpan> name;
+ Optional<chip::CharSpan> callSign;
+ Optional<chip::CharSpan> affiliateCallSign;
+ Optional<chip::CharSpan> identifier;
+ Optional<ChannelTypeEnum> type;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ChannelInfoStruct
+namespace ProgramStruct {
+enum class Fields : uint8_t
+{
+ kIdentifier = 0,
+ kChannel = 1,
+ kStartTime = 2,
+ kEndTime = 3,
+ kTitle = 4,
+ kSubtitle = 5,
+ kDescription = 6,
+ kAudioLanguages = 7,
+ kRatings = 8,
+ kThumbnailUrl = 9,
+ kPosterArtUrl = 10,
+ kDvbiUrl = 11,
+ kReleaseDate = 12,
+ kParentalGuidanceText = 13,
+ kRecordingFlag = 14,
+ kSeriesInfo = 15,
+ kCategoryList = 16,
+ kCastList = 17,
+ kExternalIDList = 18,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan identifier;
+ Structs::ChannelInfoStruct::Type channel;
+ uint32_t startTime = static_cast<uint32_t>(0);
+ uint32_t endTime = static_cast<uint32_t>(0);
+ chip::CharSpan title;
+ Optional<chip::CharSpan> subtitle;
+ Optional<chip::CharSpan> description;
+ Optional<DataModel::List<const chip::CharSpan>> audioLanguages;
+ Optional<DataModel::List<const chip::CharSpan>> ratings;
+ Optional<chip::CharSpan> thumbnailUrl;
+ Optional<chip::CharSpan> posterArtUrl;
+ Optional<chip::CharSpan> dvbiUrl;
+ Optional<chip::CharSpan> releaseDate;
+ Optional<chip::CharSpan> parentalGuidanceText;
+ Optional<chip::BitMask<RecordingFlagBitmap>> recordingFlag;
+ Optional<DataModel::Nullable<Structs::SeriesInfoStruct::Type>> seriesInfo;
+ Optional<DataModel::List<const Structs::ProgramCategoryStruct::Type>> categoryList;
+ Optional<DataModel::List<const Structs::ProgramCastStruct::Type>> castList;
+ Optional<DataModel::List<const Structs::ProgramCastStruct::Type>> externalIDList;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::CharSpan identifier;
+ Structs::ChannelInfoStruct::DecodableType channel;
+ uint32_t startTime = static_cast<uint32_t>(0);
+ uint32_t endTime = static_cast<uint32_t>(0);
+ chip::CharSpan title;
+ Optional<chip::CharSpan> subtitle;
+ Optional<chip::CharSpan> description;
+ Optional<DataModel::DecodableList<chip::CharSpan>> audioLanguages;
+ Optional<DataModel::DecodableList<chip::CharSpan>> ratings;
+ Optional<chip::CharSpan> thumbnailUrl;
+ Optional<chip::CharSpan> posterArtUrl;
+ Optional<chip::CharSpan> dvbiUrl;
+ Optional<chip::CharSpan> releaseDate;
+ Optional<chip::CharSpan> parentalGuidanceText;
+ Optional<chip::BitMask<RecordingFlagBitmap>> recordingFlag;
+ Optional<DataModel::Nullable<Structs::SeriesInfoStruct::DecodableType>> seriesInfo;
+ Optional<DataModel::DecodableList<Structs::ProgramCategoryStruct::DecodableType>> categoryList;
+ Optional<DataModel::DecodableList<Structs::ProgramCastStruct::DecodableType>> castList;
+ Optional<DataModel::DecodableList<Structs::ProgramCastStruct::DecodableType>> externalIDList;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ProgramStruct
+namespace PageTokenStruct {
+enum class Fields : uint8_t
+{
+ kLimit = 0,
+ kAfter = 1,
+ kBefore = 2,
+};
+
+struct Type
+{
+public:
+ Optional<uint16_t> limit;
+ Optional<chip::CharSpan> after;
+ Optional<chip::CharSpan> before;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace PageTokenStruct
+namespace ChannelPagingStruct {
+enum class Fields : uint8_t
+{
+ kPreviousToken = 0,
+ kNextToken = 1,
+};
+
+struct Type
+{
+public:
+ Optional<DataModel::Nullable<Structs::PageTokenStruct::Type>> previousToken;
+ Optional<DataModel::Nullable<Structs::PageTokenStruct::Type>> nextToken;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ChannelPagingStruct
+namespace AdditionalInfoStruct {
+enum class Fields : uint8_t
+{
+ kName = 0,
+ kValue = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan name;
+ chip::CharSpan value;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AdditionalInfoStruct
+namespace LineupInfoStruct {
+enum class Fields : uint8_t
+{
+ kOperatorName = 0,
+ kLineupName = 1,
+ kPostalCode = 2,
+ kLineupInfoType = 3,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan operatorName;
+ Optional<chip::CharSpan> lineupName;
+ Optional<chip::CharSpan> postalCode;
+ LineupInfoTypeEnum lineupInfoType = static_cast<LineupInfoTypeEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace LineupInfoStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ChangeChannel {
+struct Type;
+struct DecodableType;
+} // namespace ChangeChannel
+
+namespace ChangeChannelResponse {
+struct Type;
+struct DecodableType;
+} // namespace ChangeChannelResponse
+
+namespace ChangeChannelByNumber {
+struct Type;
+struct DecodableType;
+} // namespace ChangeChannelByNumber
+
+namespace SkipChannel {
+struct Type;
+struct DecodableType;
+} // namespace SkipChannel
+
+namespace GetProgramGuide {
+struct Type;
+struct DecodableType;
+} // namespace GetProgramGuide
+
+namespace ProgramGuideResponse {
+struct Type;
+struct DecodableType;
+} // namespace ProgramGuideResponse
+
+namespace RecordProgram {
+struct Type;
+struct DecodableType;
+} // namespace RecordProgram
+
+namespace CancelRecordProgram {
+struct Type;
+struct DecodableType;
+} // namespace CancelRecordProgram
+
+} // namespace Commands
+
+namespace Commands {
+namespace ChangeChannel {
+enum class Fields : uint8_t
+{
+ kMatch = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeChannel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ chip::CharSpan match;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Channel::Commands::ChangeChannelResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeChannel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ chip::CharSpan match;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeChannel
+namespace ChangeChannelResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeChannelResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeChannelResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeChannelResponse
+namespace ChangeChannelByNumber {
+enum class Fields : uint8_t
+{
+ kMajorNumber = 0,
+ kMinorNumber = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ChangeChannelByNumber::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ uint16_t majorNumber = static_cast<uint16_t>(0);
+ uint16_t minorNumber = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ChangeChannelByNumber::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ uint16_t majorNumber = static_cast<uint16_t>(0);
+ uint16_t minorNumber = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ChangeChannelByNumber
+namespace SkipChannel {
+enum class Fields : uint8_t
+{
+ kCount = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SkipChannel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ int16_t count = static_cast<int16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SkipChannel::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ int16_t count = static_cast<int16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SkipChannel
+namespace GetProgramGuide {
+enum class Fields : uint8_t
+{
+ kStartTime = 0,
+ kEndTime = 1,
+ kChannelList = 2,
+ kPageToken = 3,
+ kRecordingFlag = 4,
+ kExternalIDList = 5,
+ kData = 6,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetProgramGuide::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ Optional<uint32_t> startTime;
+ Optional<uint32_t> endTime;
+ Optional<DataModel::List<const Structs::ChannelInfoStruct::Type>> channelList;
+ Optional<Structs::PageTokenStruct::Type> pageToken;
+ Optional<chip::BitMask<RecordingFlagBitmap>> recordingFlag;
+ Optional<DataModel::List<const Structs::AdditionalInfoStruct::Type>> externalIDList;
+ Optional<chip::ByteSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::Channel::Commands::ProgramGuideResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetProgramGuide::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ Optional<uint32_t> startTime;
+ Optional<uint32_t> endTime;
+ Optional<DataModel::DecodableList<Structs::ChannelInfoStruct::DecodableType>> channelList;
+ Optional<Structs::PageTokenStruct::DecodableType> pageToken;
+ Optional<chip::BitMask<RecordingFlagBitmap>> recordingFlag;
+ Optional<DataModel::DecodableList<Structs::AdditionalInfoStruct::DecodableType>> externalIDList;
+ Optional<chip::ByteSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetProgramGuide
+namespace ProgramGuideResponse {
+enum class Fields : uint8_t
+{
+ kPaging = 0,
+ kProgramList = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ProgramGuideResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ Structs::ChannelPagingStruct::Type paging;
+ DataModel::List<const Structs::ProgramStruct::Type> programList;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ProgramGuideResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ Structs::ChannelPagingStruct::DecodableType paging;
+ DataModel::DecodableList<Structs::ProgramStruct::DecodableType> programList;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ProgramGuideResponse
+namespace RecordProgram {
+enum class Fields : uint8_t
+{
+ kProgramIdentifier = 0,
+ kShouldRecordSeries = 1,
+ kExternalIDList = 2,
+ kData = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RecordProgram::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ chip::CharSpan programIdentifier;
+ bool shouldRecordSeries = static_cast<bool>(0);
+ DataModel::List<const Structs::AdditionalInfoStruct::Type> externalIDList;
+ chip::ByteSpan data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RecordProgram::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ chip::CharSpan programIdentifier;
+ bool shouldRecordSeries = static_cast<bool>(0);
+ DataModel::DecodableList<Structs::AdditionalInfoStruct::DecodableType> externalIDList;
+ chip::ByteSpan data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RecordProgram
+namespace CancelRecordProgram {
+enum class Fields : uint8_t
+{
+ kProgramIdentifier = 0,
+ kShouldRecordSeries = 1,
+ kExternalIDList = 2,
+ kData = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CancelRecordProgram::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ chip::CharSpan programIdentifier;
+ bool shouldRecordSeries = static_cast<bool>(0);
+ DataModel::List<const Structs::AdditionalInfoStruct::Type> externalIDList;
+ chip::ByteSpan data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CancelRecordProgram::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ chip::CharSpan programIdentifier;
+ bool shouldRecordSeries = static_cast<bool>(0);
+ DataModel::DecodableList<Structs::AdditionalInfoStruct::DecodableType> externalIDList;
+ chip::ByteSpan data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CancelRecordProgram
+} // namespace Commands
+
+namespace Attributes {
+
+namespace ChannelList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Channel::Structs::ChannelInfoStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::Channel::Structs::ChannelInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Channel::Structs::ChannelInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ChannelList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ChannelList
+namespace Lineup {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfoStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Lineup::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Lineup
+namespace CurrentChannel {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::ChannelInfoStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::ChannelInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::ChannelInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentChannel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentChannel
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Channel::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::ChannelList::TypeInfo::DecodableType channelList;
+ Attributes::Lineup::TypeInfo::DecodableType lineup;
+ Attributes::CurrentChannel::TypeInfo::DecodableType currentChannel;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Channel
+namespace TargetNavigator {
+namespace Structs {
+namespace TargetInfoStruct {
+enum class Fields : uint8_t
+{
+ kIdentifier = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ uint8_t identifier = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TargetInfoStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace NavigateTarget {
+struct Type;
+struct DecodableType;
+} // namespace NavigateTarget
+
+namespace NavigateTargetResponse {
+struct Type;
+struct DecodableType;
+} // namespace NavigateTargetResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace NavigateTarget {
+enum class Fields : uint8_t
+{
+ kTarget = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NavigateTarget::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+
+ uint8_t target = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::TargetNavigator::Commands::NavigateTargetResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NavigateTarget::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+
+ uint8_t target = static_cast<uint8_t>(0);
+ Optional<chip::CharSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NavigateTarget
+namespace NavigateTargetResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::NavigateTargetResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::NavigateTargetResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace NavigateTargetResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace TargetList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::TargetNavigator::Structs::TargetInfoStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::TargetNavigator::Structs::TargetInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::TargetNavigator::Structs::TargetInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TargetList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TargetList
+namespace CurrentTarget {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentTarget::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentTarget
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::TargetList::TypeInfo::DecodableType targetList;
+ Attributes::CurrentTarget::TypeInfo::DecodableType currentTarget = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace TargetUpdated {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kTargetList = 0,
+ kCurrentTarget = 1,
+ kData = 2,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TargetUpdated::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const Structs::TargetInfoStruct::Type> targetList;
+ uint8_t currentTarget = static_cast<uint8_t>(0);
+ chip::ByteSpan data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TargetUpdated::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; }
+
+ DataModel::DecodableList<Structs::TargetInfoStruct::DecodableType> targetList;
+ uint8_t currentTarget = static_cast<uint8_t>(0);
+ chip::ByteSpan data;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TargetUpdated
+} // namespace Events
+} // namespace TargetNavigator
+namespace MediaPlayback {
+namespace Structs {
+namespace TrackAttributesStruct {
+enum class Fields : uint8_t
+{
+ kLanguageCode = 0,
+ kDisplayName = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan languageCode;
+ Optional<DataModel::Nullable<chip::CharSpan>> displayName;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TrackAttributesStruct
+namespace TrackStruct {
+enum class Fields : uint8_t
+{
+ kId = 0,
+ kTrackAttributes = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan id;
+ DataModel::Nullable<Structs::TrackAttributesStruct::Type> trackAttributes;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TrackStruct
+namespace PlaybackPositionStruct {
+enum class Fields : uint8_t
+{
+ kUpdatedAt = 0,
+ kPosition = 1,
+};
+
+struct Type
+{
+public:
+ uint64_t updatedAt = static_cast<uint64_t>(0);
+ DataModel::Nullable<uint64_t> position;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace PlaybackPositionStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Play {
+struct Type;
+struct DecodableType;
+} // namespace Play
+
+namespace Pause {
+struct Type;
+struct DecodableType;
+} // namespace Pause
+
+namespace Stop {
+struct Type;
+struct DecodableType;
+} // namespace Stop
+
+namespace StartOver {
+struct Type;
+struct DecodableType;
+} // namespace StartOver
+
+namespace Previous {
+struct Type;
+struct DecodableType;
+} // namespace Previous
+
+namespace Next {
+struct Type;
+struct DecodableType;
+} // namespace Next
+
+namespace Rewind {
+struct Type;
+struct DecodableType;
+} // namespace Rewind
+
+namespace FastForward {
+struct Type;
+struct DecodableType;
+} // namespace FastForward
+
+namespace SkipForward {
+struct Type;
+struct DecodableType;
+} // namespace SkipForward
+
+namespace SkipBackward {
+struct Type;
+struct DecodableType;
+} // namespace SkipBackward
+
+namespace PlaybackResponse {
+struct Type;
+struct DecodableType;
+} // namespace PlaybackResponse
+
+namespace Seek {
+struct Type;
+struct DecodableType;
+} // namespace Seek
+
+namespace ActivateAudioTrack {
+struct Type;
+struct DecodableType;
+} // namespace ActivateAudioTrack
+
+namespace ActivateTextTrack {
+struct Type;
+struct DecodableType;
+} // namespace ActivateTextTrack
+
+namespace DeactivateTextTrack {
+struct Type;
+struct DecodableType;
+} // namespace DeactivateTextTrack
+
+} // namespace Commands
+
+namespace Commands {
+namespace Play {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Play::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Play::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Play
+namespace Pause {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Pause::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Pause
+namespace Stop {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Stop::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Stop
+namespace StartOver {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StartOver::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StartOver::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StartOver
+namespace Previous {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Previous::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Previous::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Previous
+namespace Next {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Next::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Next::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Next
+namespace Rewind {
+enum class Fields : uint8_t
+{
+ kAudioAdvanceUnmuted = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Rewind::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ Optional<bool> audioAdvanceUnmuted;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Rewind::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ Optional<bool> audioAdvanceUnmuted;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Rewind
+namespace FastForward {
+enum class Fields : uint8_t
+{
+ kAudioAdvanceUnmuted = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::FastForward::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ Optional<bool> audioAdvanceUnmuted;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::FastForward::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ Optional<bool> audioAdvanceUnmuted;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace FastForward
+namespace SkipForward {
+enum class Fields : uint8_t
+{
+ kDeltaPositionMilliseconds = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SkipForward::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ uint64_t deltaPositionMilliseconds = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SkipForward::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ uint64_t deltaPositionMilliseconds = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SkipForward
+namespace SkipBackward {
+enum class Fields : uint8_t
+{
+ kDeltaPositionMilliseconds = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SkipBackward::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ uint64_t deltaPositionMilliseconds = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SkipBackward::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ uint64_t deltaPositionMilliseconds = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SkipBackward
+namespace PlaybackResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PlaybackResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PlaybackResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PlaybackResponse
+namespace Seek {
+enum class Fields : uint8_t
+{
+ kPosition = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Seek::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ uint64_t position = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Seek::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ uint64_t position = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Seek
+namespace ActivateAudioTrack {
+enum class Fields : uint8_t
+{
+ kTrackID = 0,
+ kAudioOutputIndex = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ActivateAudioTrack::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ chip::CharSpan trackID;
+ uint8_t audioOutputIndex = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ActivateAudioTrack::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ chip::CharSpan trackID;
+ uint8_t audioOutputIndex = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ActivateAudioTrack
+namespace ActivateTextTrack {
+enum class Fields : uint8_t
+{
+ kTrackID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ActivateTextTrack::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ chip::CharSpan trackID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ActivateTextTrack::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ chip::CharSpan trackID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ActivateTextTrack
+namespace DeactivateTextTrack {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DeactivateTextTrack::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DeactivateTextTrack::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DeactivateTextTrack
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CurrentState {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::MediaPlayback::PlaybackStateEnum;
+ using DecodableType = chip::app::Clusters::MediaPlayback::PlaybackStateEnum;
+ using DecodableArgType = chip::app::Clusters::MediaPlayback::PlaybackStateEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentState::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentState
+namespace StartTime {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StartTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StartTime
+namespace Duration {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Duration::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Duration
+namespace SampledPosition {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::PlaybackPositionStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::PlaybackPositionStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::PlaybackPositionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SampledPosition::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SampledPosition
+namespace PlaybackSpeed {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PlaybackSpeed::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PlaybackSpeed
+namespace SeekRangeEnd {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SeekRangeEnd::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SeekRangeEnd
+namespace SeekRangeStart {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SeekRangeStart::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SeekRangeStart
+namespace ActiveAudioTrack {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveAudioTrack::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveAudioTrack
+namespace AvailableAudioTracks {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<
+ chip::app::DataModel::List<const chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::DataModel::DecodableList<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::DataModel::DecodableList<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AvailableAudioTracks::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AvailableAudioTracks
+namespace ActiveTextTrack {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveTextTrack::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveTextTrack
+namespace AvailableTextTracks {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<
+ chip::app::DataModel::List<const chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>>;
+ using DecodableType = chip::app::DataModel::Nullable<
+ chip::app::DataModel::DecodableList<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType>>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::DataModel::DecodableList<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::DecodableType>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AvailableTextTracks::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AvailableTextTracks
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CurrentState::TypeInfo::DecodableType currentState =
+ static_cast<chip::app::Clusters::MediaPlayback::PlaybackStateEnum>(0);
+ Attributes::StartTime::TypeInfo::DecodableType startTime;
+ Attributes::Duration::TypeInfo::DecodableType duration;
+ Attributes::SampledPosition::TypeInfo::DecodableType sampledPosition;
+ Attributes::PlaybackSpeed::TypeInfo::DecodableType playbackSpeed = static_cast<float>(0);
+ Attributes::SeekRangeEnd::TypeInfo::DecodableType seekRangeEnd;
+ Attributes::SeekRangeStart::TypeInfo::DecodableType seekRangeStart;
+ Attributes::ActiveAudioTrack::TypeInfo::DecodableType activeAudioTrack;
+ Attributes::AvailableAudioTracks::TypeInfo::DecodableType availableAudioTracks;
+ Attributes::ActiveTextTrack::TypeInfo::DecodableType activeTextTrack;
+ Attributes::AvailableTextTracks::TypeInfo::DecodableType availableTextTracks;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace StateChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCurrentState = 0,
+ kStartTime = 1,
+ kDuration = 2,
+ kSampledPosition = 3,
+ kPlaybackSpeed = 4,
+ kSeekRangeEnd = 5,
+ kSeekRangeStart = 6,
+ kData = 7,
+ kAudioAdvanceUnmuted = 8,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ PlaybackStateEnum currentState = static_cast<PlaybackStateEnum>(0);
+ uint64_t startTime = static_cast<uint64_t>(0);
+ uint64_t duration = static_cast<uint64_t>(0);
+ Structs::PlaybackPositionStruct::Type sampledPosition;
+ float playbackSpeed = static_cast<float>(0);
+ uint64_t seekRangeEnd = static_cast<uint64_t>(0);
+ uint64_t seekRangeStart = static_cast<uint64_t>(0);
+ Optional<chip::ByteSpan> data;
+ bool audioAdvanceUnmuted = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::StateChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; }
+
+ PlaybackStateEnum currentState = static_cast<PlaybackStateEnum>(0);
+ uint64_t startTime = static_cast<uint64_t>(0);
+ uint64_t duration = static_cast<uint64_t>(0);
+ Structs::PlaybackPositionStruct::DecodableType sampledPosition;
+ float playbackSpeed = static_cast<float>(0);
+ uint64_t seekRangeEnd = static_cast<uint64_t>(0);
+ uint64_t seekRangeStart = static_cast<uint64_t>(0);
+ Optional<chip::ByteSpan> data;
+ bool audioAdvanceUnmuted = static_cast<bool>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace StateChanged
+} // namespace Events
+} // namespace MediaPlayback
+namespace MediaInput {
+namespace Structs {
+namespace InputInfoStruct {
+enum class Fields : uint8_t
+{
+ kIndex = 0,
+ kInputType = 1,
+ kName = 2,
+ kDescription = 3,
+};
+
+struct Type
+{
+public:
+ uint8_t index = static_cast<uint8_t>(0);
+ InputTypeEnum inputType = static_cast<InputTypeEnum>(0);
+ chip::CharSpan name;
+ chip::CharSpan description;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace InputInfoStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SelectInput {
+struct Type;
+struct DecodableType;
+} // namespace SelectInput
+
+namespace ShowInputStatus {
+struct Type;
+struct DecodableType;
+} // namespace ShowInputStatus
+
+namespace HideInputStatus {
+struct Type;
+struct DecodableType;
+} // namespace HideInputStatus
+
+namespace RenameInput {
+struct Type;
+struct DecodableType;
+} // namespace RenameInput
+
+} // namespace Commands
+
+namespace Commands {
+namespace SelectInput {
+enum class Fields : uint8_t
+{
+ kIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SelectInput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SelectInput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelectInput
+namespace ShowInputStatus {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ShowInputStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ShowInputStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ShowInputStatus
+namespace HideInputStatus {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::HideInputStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::HideInputStatus::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace HideInputStatus
+namespace RenameInput {
+enum class Fields : uint8_t
+{
+ kIndex = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RenameInput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RenameInput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RenameInput
+} // namespace Commands
+
+namespace Attributes {
+
+namespace InputList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::MediaInput::Structs::InputInfoStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::MediaInput::Structs::InputInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::MediaInput::Structs::InputInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InputList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InputList
+namespace CurrentInput {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentInput::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentInput
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::InputList::TypeInfo::DecodableType inputList;
+ Attributes::CurrentInput::TypeInfo::DecodableType currentInput = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace MediaInput
+namespace LowPower {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Sleep {
+struct Type;
+struct DecodableType;
+} // namespace Sleep
+
+} // namespace Commands
+
+namespace Commands {
+namespace Sleep {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Sleep::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Sleep::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Sleep
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace LowPower
+namespace KeypadInput {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SendKey {
+struct Type;
+struct DecodableType;
+} // namespace SendKey
+
+namespace SendKeyResponse {
+struct Type;
+struct DecodableType;
+} // namespace SendKeyResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace SendKey {
+enum class Fields : uint8_t
+{
+ kKeyCode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SendKey::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+
+ CECKeyCodeEnum keyCode = static_cast<CECKeyCodeEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::KeypadInput::Commands::SendKeyResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SendKey::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+
+ CECKeyCodeEnum keyCode = static_cast<CECKeyCodeEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SendKey
+namespace SendKeyResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SendKeyResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SendKeyResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SendKeyResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace KeypadInput
+namespace ContentLauncher {
+namespace Structs {
+namespace DimensionStruct {
+enum class Fields : uint8_t
+{
+ kWidth = 0,
+ kHeight = 1,
+ kMetric = 2,
+};
+
+struct Type
+{
+public:
+ double width = static_cast<double>(0);
+ double height = static_cast<double>(0);
+ MetricTypeEnum metric = static_cast<MetricTypeEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace DimensionStruct
+namespace TrackPreferenceStruct {
+enum class Fields : uint8_t
+{
+ kLanguageCode = 0,
+ kCharacteristics = 1,
+ kAudioOutputIndex = 2,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan languageCode;
+ Optional<DataModel::List<const CharacteristicEnum>> characteristics;
+ uint8_t audioOutputIndex = static_cast<uint8_t>(0);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::CharSpan languageCode;
+ Optional<DataModel::DecodableList<CharacteristicEnum>> characteristics;
+ uint8_t audioOutputIndex = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace TrackPreferenceStruct
+namespace PlaybackPreferencesStruct {
+enum class Fields : uint8_t
+{
+ kPlaybackPosition = 0,
+ kTextTrack = 1,
+ kAudioTracks = 2,
+};
+
+struct Type
+{
+public:
+ uint64_t playbackPosition = static_cast<uint64_t>(0);
+ Structs::TrackPreferenceStruct::Type textTrack;
+ Optional<DataModel::List<const Structs::TrackPreferenceStruct::Type>> audioTracks;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ uint64_t playbackPosition = static_cast<uint64_t>(0);
+ Structs::TrackPreferenceStruct::DecodableType textTrack;
+ Optional<DataModel::DecodableList<Structs::TrackPreferenceStruct::DecodableType>> audioTracks;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace PlaybackPreferencesStruct
+namespace AdditionalInfoStruct {
+enum class Fields : uint8_t
+{
+ kName = 0,
+ kValue = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan name;
+ chip::CharSpan value;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AdditionalInfoStruct
+namespace ParameterStruct {
+enum class Fields : uint8_t
+{
+ kType = 0,
+ kValue = 1,
+ kExternalIDList = 2,
+};
+
+struct Type
+{
+public:
+ ParameterEnum type = static_cast<ParameterEnum>(0);
+ chip::CharSpan value;
+ Optional<DataModel::List<const Structs::AdditionalInfoStruct::Type>> externalIDList;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ ParameterEnum type = static_cast<ParameterEnum>(0);
+ chip::CharSpan value;
+ Optional<DataModel::DecodableList<Structs::AdditionalInfoStruct::DecodableType>> externalIDList;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ParameterStruct
+namespace ContentSearchStruct {
+enum class Fields : uint8_t
+{
+ kParameterList = 0,
+};
+
+struct Type
+{
+public:
+ DataModel::List<const Structs::ParameterStruct::Type> parameterList;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::DecodableList<Structs::ParameterStruct::DecodableType> parameterList;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace ContentSearchStruct
+namespace StyleInformationStruct {
+enum class Fields : uint8_t
+{
+ kImageURL = 0,
+ kColor = 1,
+ kSize = 2,
+};
+
+struct Type
+{
+public:
+ Optional<chip::CharSpan> imageURL;
+ Optional<chip::CharSpan> color;
+ Optional<Structs::DimensionStruct::Type> size;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace StyleInformationStruct
+namespace BrandingInformationStruct {
+enum class Fields : uint8_t
+{
+ kProviderName = 0,
+ kBackground = 1,
+ kLogo = 2,
+ kProgressBar = 3,
+ kSplash = 4,
+ kWaterMark = 5,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan providerName;
+ Optional<Structs::StyleInformationStruct::Type> background;
+ Optional<Structs::StyleInformationStruct::Type> logo;
+ Optional<Structs::StyleInformationStruct::Type> progressBar;
+ Optional<Structs::StyleInformationStruct::Type> splash;
+ Optional<Structs::StyleInformationStruct::Type> waterMark;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace BrandingInformationStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace LaunchContent {
+struct Type;
+struct DecodableType;
+} // namespace LaunchContent
+
+namespace LaunchURL {
+struct Type;
+struct DecodableType;
+} // namespace LaunchURL
+
+namespace LauncherResponse {
+struct Type;
+struct DecodableType;
+} // namespace LauncherResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace LaunchContent {
+enum class Fields : uint8_t
+{
+ kSearch = 0,
+ kAutoPlay = 1,
+ kData = 2,
+ kPlaybackPreferences = 3,
+ kUseCurrentContext = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::LaunchContent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ Structs::ContentSearchStruct::Type search;
+ bool autoPlay = static_cast<bool>(0);
+ Optional<chip::CharSpan> data;
+ Optional<Structs::PlaybackPreferencesStruct::Type> playbackPreferences;
+ Optional<bool> useCurrentContext;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ContentLauncher::Commands::LauncherResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::LaunchContent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ Structs::ContentSearchStruct::DecodableType search;
+ bool autoPlay = static_cast<bool>(0);
+ Optional<chip::CharSpan> data;
+ Optional<Structs::PlaybackPreferencesStruct::DecodableType> playbackPreferences;
+ Optional<bool> useCurrentContext;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchContent
+namespace LaunchURL {
+enum class Fields : uint8_t
+{
+ kContentURL = 0,
+ kDisplayString = 1,
+ kBrandingInformation = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::LaunchURL::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ chip::CharSpan contentURL;
+ Optional<chip::CharSpan> displayString;
+ Optional<Structs::BrandingInformationStruct::Type> brandingInformation;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ContentLauncher::Commands::LauncherResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::LaunchURL::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ chip::CharSpan contentURL;
+ Optional<chip::CharSpan> displayString;
+ Optional<Structs::BrandingInformationStruct::DecodableType> brandingInformation;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchURL
+namespace LauncherResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::LauncherResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::LauncherResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LauncherResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace AcceptHeader {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AcceptHeader::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AcceptHeader
+namespace SupportedStreamingProtocols {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedStreamingProtocols::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedStreamingProtocols
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::AcceptHeader::TypeInfo::DecodableType acceptHeader;
+ Attributes::SupportedStreamingProtocols::TypeInfo::DecodableType supportedStreamingProtocols =
+ static_cast<chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ContentLauncher
+namespace AudioOutput {
+namespace Structs {
+namespace OutputInfoStruct {
+enum class Fields : uint8_t
+{
+ kIndex = 0,
+ kOutputType = 1,
+ kName = 2,
+};
+
+struct Type
+{
+public:
+ uint8_t index = static_cast<uint8_t>(0);
+ OutputTypeEnum outputType = static_cast<OutputTypeEnum>(0);
+ chip::CharSpan name;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace OutputInfoStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SelectOutput {
+struct Type;
+struct DecodableType;
+} // namespace SelectOutput
+
+namespace RenameOutput {
+struct Type;
+struct DecodableType;
+} // namespace RenameOutput
+
+} // namespace Commands
+
+namespace Commands {
+namespace SelectOutput {
+enum class Fields : uint8_t
+{
+ kIndex = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SelectOutput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SelectOutput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SelectOutput
+namespace RenameOutput {
+enum class Fields : uint8_t
+{
+ kIndex = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RenameOutput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RenameOutput::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+
+ uint8_t index = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RenameOutput
+} // namespace Commands
+
+namespace Attributes {
+
+namespace OutputList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::AudioOutput::Structs::OutputInfoStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::AudioOutput::Structs::OutputInfoStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::AudioOutput::Structs::OutputInfoStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OutputList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OutputList
+namespace CurrentOutput {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentOutput::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentOutput
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::OutputList::TypeInfo::DecodableType outputList;
+ Attributes::CurrentOutput::TypeInfo::DecodableType currentOutput = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace AudioOutput
+namespace ApplicationLauncher {
+namespace Structs {
+namespace ApplicationStruct = Clusters::detail::Structs::ApplicationStruct;
+namespace ApplicationEPStruct {
+enum class Fields : uint8_t
+{
+ kApplication = 0,
+ kEndpoint = 1,
+};
+
+struct Type
+{
+public:
+ Structs::ApplicationStruct::Type application;
+ Optional<chip::EndpointId> endpoint;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ApplicationEPStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace LaunchApp {
+struct Type;
+struct DecodableType;
+} // namespace LaunchApp
+
+namespace StopApp {
+struct Type;
+struct DecodableType;
+} // namespace StopApp
+
+namespace HideApp {
+struct Type;
+struct DecodableType;
+} // namespace HideApp
+
+namespace LauncherResponse {
+struct Type;
+struct DecodableType;
+} // namespace LauncherResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace LaunchApp {
+enum class Fields : uint8_t
+{
+ kApplication = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::LaunchApp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ Optional<Structs::ApplicationStruct::Type> application;
+ Optional<chip::ByteSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::LaunchApp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ Optional<Structs::ApplicationStruct::DecodableType> application;
+ Optional<chip::ByteSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LaunchApp
+namespace StopApp {
+enum class Fields : uint8_t
+{
+ kApplication = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StopApp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ Optional<Structs::ApplicationStruct::Type> application;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StopApp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ Optional<Structs::ApplicationStruct::DecodableType> application;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StopApp
+namespace HideApp {
+enum class Fields : uint8_t
+{
+ kApplication = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::HideApp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ Optional<Structs::ApplicationStruct::Type> application;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::HideApp::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ Optional<Structs::ApplicationStruct::DecodableType> application;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace HideApp
+namespace LauncherResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kData = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::LauncherResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::ByteSpan> data;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::LauncherResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::ByteSpan> data;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace LauncherResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CatalogList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const uint16_t>;
+ using DecodableType = chip::app::DataModel::DecodableList<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CatalogList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CatalogList
+namespace CurrentApp {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEPStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEPStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<
+ chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEPStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentApp::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentApp
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CatalogList::TypeInfo::DecodableType catalogList;
+ Attributes::CurrentApp::TypeInfo::DecodableType currentApp;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ApplicationLauncher
+namespace ApplicationBasic {
+namespace Structs {
+namespace ApplicationStruct = Clusters::detail::Structs::ApplicationStruct;
+} // namespace Structs
+
+namespace Attributes {
+
+namespace VendorName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace VendorName
+namespace VendorID {
+struct TypeInfo
+{
+ using Type = chip::VendorId;
+ using DecodableType = chip::VendorId;
+ using DecodableArgType = chip::VendorId;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace VendorID
+namespace ApplicationName {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationName::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 256; }
+};
+} // namespace ApplicationName
+namespace ProductID {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ProductID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ProductID
+namespace Application {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ApplicationBasic::Structs::ApplicationStruct::Type;
+ using DecodableType = chip::app::Clusters::ApplicationBasic::Structs::ApplicationStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::ApplicationBasic::Structs::ApplicationStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Application::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Application
+namespace Status {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum;
+ using DecodableType = chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum;
+ using DecodableArgType = chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Status::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Status
+namespace ApplicationVersion {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationVersion::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 32; }
+};
+} // namespace ApplicationVersion
+namespace AllowedVendorList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::VendorId>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::VendorId>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::VendorId> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AllowedVendorList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AllowedVendorList
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::VendorName::TypeInfo::DecodableType vendorName;
+ Attributes::VendorID::TypeInfo::DecodableType vendorID = static_cast<chip::VendorId>(0);
+ Attributes::ApplicationName::TypeInfo::DecodableType applicationName;
+ Attributes::ProductID::TypeInfo::DecodableType productID = static_cast<uint16_t>(0);
+ Attributes::Application::TypeInfo::DecodableType application;
+ Attributes::Status::TypeInfo::DecodableType status =
+ static_cast<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum>(0);
+ Attributes::ApplicationVersion::TypeInfo::DecodableType applicationVersion;
+ Attributes::AllowedVendorList::TypeInfo::DecodableType allowedVendorList;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ApplicationBasic
+namespace AccountLogin {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace GetSetupPIN {
+struct Type;
+struct DecodableType;
+} // namespace GetSetupPIN
+
+namespace GetSetupPINResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetSetupPINResponse
+
+namespace Login {
+struct Type;
+struct DecodableType;
+} // namespace Login
+
+namespace Logout {
+struct Type;
+struct DecodableType;
+} // namespace Logout
+
+} // namespace Commands
+
+namespace Commands {
+namespace GetSetupPIN {
+enum class Fields : uint8_t
+{
+ kTempAccountIdentifier = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetSetupPIN::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ chip::CharSpan tempAccountIdentifier;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::AccountLogin::Commands::GetSetupPINResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetSetupPIN::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ chip::CharSpan tempAccountIdentifier;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSetupPIN
+namespace GetSetupPINResponse {
+enum class Fields : uint8_t
+{
+ kSetupPIN = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetSetupPINResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ chip::CharSpan setupPIN;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetSetupPINResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ chip::CharSpan setupPIN;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetSetupPINResponse
+namespace Login {
+enum class Fields : uint8_t
+{
+ kTempAccountIdentifier = 0,
+ kSetupPIN = 1,
+ kNode = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Login::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ chip::CharSpan tempAccountIdentifier;
+ chip::CharSpan setupPIN;
+ Optional<chip::NodeId> node;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Login::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ chip::CharSpan tempAccountIdentifier;
+ chip::CharSpan setupPIN;
+ Optional<chip::NodeId> node;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Login
+namespace Logout {
+enum class Fields : uint8_t
+{
+ kNode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Logout::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ Optional<chip::NodeId> node;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Logout::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ Optional<chip::NodeId> node;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Logout
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace LoggedOut {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical;
+
+enum class Fields : uint8_t
+{
+ kNode = 0,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LoggedOut::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ Optional<chip::NodeId> node;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::LoggedOut::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; }
+
+ Optional<chip::NodeId> node;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace LoggedOut
+} // namespace Events
+} // namespace AccountLogin
+namespace ContentControl {
+namespace Structs {
+namespace RatingNameStruct {
+enum class Fields : uint8_t
+{
+ kRatingName = 0,
+ kRatingNameDesc = 1,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan ratingName;
+ Optional<chip::CharSpan> ratingNameDesc;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace RatingNameStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace UpdatePIN {
+struct Type;
+struct DecodableType;
+} // namespace UpdatePIN
+
+namespace ResetPIN {
+struct Type;
+struct DecodableType;
+} // namespace ResetPIN
+
+namespace ResetPINResponse {
+struct Type;
+struct DecodableType;
+} // namespace ResetPINResponse
+
+namespace Enable {
+struct Type;
+struct DecodableType;
+} // namespace Enable
+
+namespace Disable {
+struct Type;
+struct DecodableType;
+} // namespace Disable
+
+namespace AddBonusTime {
+struct Type;
+struct DecodableType;
+} // namespace AddBonusTime
+
+namespace SetScreenDailyTime {
+struct Type;
+struct DecodableType;
+} // namespace SetScreenDailyTime
+
+namespace BlockUnratedContent {
+struct Type;
+struct DecodableType;
+} // namespace BlockUnratedContent
+
+namespace UnblockUnratedContent {
+struct Type;
+struct DecodableType;
+} // namespace UnblockUnratedContent
+
+namespace SetOnDemandRatingThreshold {
+struct Type;
+struct DecodableType;
+} // namespace SetOnDemandRatingThreshold
+
+namespace SetScheduledContentRatingThreshold {
+struct Type;
+struct DecodableType;
+} // namespace SetScheduledContentRatingThreshold
+
+} // namespace Commands
+
+namespace Commands {
+namespace UpdatePIN {
+enum class Fields : uint8_t
+{
+ kOldPIN = 0,
+ kNewPIN = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UpdatePIN::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ Optional<chip::CharSpan> oldPIN;
+ chip::CharSpan newPIN;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UpdatePIN::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ Optional<chip::CharSpan> oldPIN;
+ chip::CharSpan newPIN;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdatePIN
+namespace ResetPIN {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetPIN::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ContentControl::Commands::ResetPINResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetPIN::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetPIN
+namespace ResetPINResponse {
+enum class Fields : uint8_t
+{
+ kPINCode = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ResetPINResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ chip::CharSpan PINCode;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ResetPINResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ chip::CharSpan PINCode;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ResetPINResponse
+namespace Enable {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Enable::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Enable::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Enable
+namespace Disable {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Disable::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Disable::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Disable
+namespace AddBonusTime {
+enum class Fields : uint8_t
+{
+ kPINCode = 0,
+ kBonusTime = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddBonusTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ Optional<chip::CharSpan> PINCode;
+ Optional<uint32_t> bonusTime;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddBonusTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ Optional<chip::CharSpan> PINCode;
+ Optional<uint32_t> bonusTime;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddBonusTime
+namespace SetScreenDailyTime {
+enum class Fields : uint8_t
+{
+ kScreenTime = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetScreenDailyTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ uint32_t screenTime = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetScreenDailyTime::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ uint32_t screenTime = static_cast<uint32_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetScreenDailyTime
+namespace BlockUnratedContent {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::BlockUnratedContent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::BlockUnratedContent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace BlockUnratedContent
+namespace UnblockUnratedContent {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UnblockUnratedContent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UnblockUnratedContent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UnblockUnratedContent
+namespace SetOnDemandRatingThreshold {
+enum class Fields : uint8_t
+{
+ kRating = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetOnDemandRatingThreshold::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ chip::CharSpan rating;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetOnDemandRatingThreshold::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ chip::CharSpan rating;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetOnDemandRatingThreshold
+namespace SetScheduledContentRatingThreshold {
+enum class Fields : uint8_t
+{
+ kRating = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetScheduledContentRatingThreshold::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ chip::CharSpan rating;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetScheduledContentRatingThreshold::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ chip::CharSpan rating;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetScheduledContentRatingThreshold
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Enabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Enabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Enabled
+namespace OnDemandRatings {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ContentControl::Structs::RatingNameStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ContentControl::Structs::RatingNameStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ContentControl::Structs::RatingNameStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnDemandRatings::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace OnDemandRatings
+namespace OnDemandRatingThreshold {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OnDemandRatingThreshold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 8; }
+};
+} // namespace OnDemandRatingThreshold
+namespace ScheduledContentRatings {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ContentControl::Structs::RatingNameStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ContentControl::Structs::RatingNameStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::ContentControl::Structs::RatingNameStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScheduledContentRatings::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScheduledContentRatings
+namespace ScheduledContentRatingThreshold {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScheduledContentRatingThreshold::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 8; }
+};
+} // namespace ScheduledContentRatingThreshold
+namespace ScreenDailyTime {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ScreenDailyTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ScreenDailyTime
+namespace RemainingScreenTime {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RemainingScreenTime::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RemainingScreenTime
+namespace BlockUnrated {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::BlockUnrated::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace BlockUnrated
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Enabled::TypeInfo::DecodableType enabled = static_cast<bool>(0);
+ Attributes::OnDemandRatings::TypeInfo::DecodableType onDemandRatings;
+ Attributes::OnDemandRatingThreshold::TypeInfo::DecodableType onDemandRatingThreshold;
+ Attributes::ScheduledContentRatings::TypeInfo::DecodableType scheduledContentRatings;
+ Attributes::ScheduledContentRatingThreshold::TypeInfo::DecodableType scheduledContentRatingThreshold;
+ Attributes::ScreenDailyTime::TypeInfo::DecodableType screenDailyTime = static_cast<uint32_t>(0);
+ Attributes::RemainingScreenTime::TypeInfo::DecodableType remainingScreenTime = static_cast<uint32_t>(0);
+ Attributes::BlockUnrated::TypeInfo::DecodableType blockUnrated = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace RemainingScreenTimeExpired {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::RemainingScreenTimeExpired::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::RemainingScreenTimeExpired::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace RemainingScreenTimeExpired
+} // namespace Events
+} // namespace ContentControl
+namespace ContentAppObserver {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace ContentAppMessage {
+struct Type;
+struct DecodableType;
+} // namespace ContentAppMessage
+
+namespace ContentAppMessageResponse {
+struct Type;
+struct DecodableType;
+} // namespace ContentAppMessageResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace ContentAppMessage {
+enum class Fields : uint8_t
+{
+ kData = 0,
+ kEncodingHint = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ContentAppMessage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+
+ Optional<chip::CharSpan> data;
+ chip::CharSpan encodingHint;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ContentAppObserver::Commands::ContentAppMessageResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ContentAppMessage::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+
+ Optional<chip::CharSpan> data;
+ chip::CharSpan encodingHint;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ContentAppMessage
+namespace ContentAppMessageResponse {
+enum class Fields : uint8_t
+{
+ kStatus = 0,
+ kData = 1,
+ kEncodingHint = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ContentAppMessageResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+ Optional<chip::CharSpan> encodingHint;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ContentAppMessageResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+
+ StatusEnum status = static_cast<StatusEnum>(0);
+ Optional<chip::CharSpan> data;
+ Optional<chip::CharSpan> encodingHint;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ContentAppMessageResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ContentAppObserver::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace ContentAppObserver
+namespace ZoneManagement {
+namespace Structs {
+namespace TwoDCartesianVertexStruct {
+enum class Fields : uint8_t
+{
+ kX = 0,
+ kY = 1,
+};
+
+struct Type
+{
+public:
+ uint16_t x = static_cast<uint16_t>(0);
+ uint16_t y = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TwoDCartesianVertexStruct
+namespace TwoDCartesianZoneStruct {
+enum class Fields : uint8_t
+{
+ kName = 0,
+ kUse = 1,
+ kVertices = 2,
+ kColor = 3,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan name;
+ ZoneUseEnum use = static_cast<ZoneUseEnum>(0);
+ DataModel::List<const Structs::TwoDCartesianVertexStruct::Type> vertices;
+ Optional<chip::CharSpan> color;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ chip::CharSpan name;
+ ZoneUseEnum use = static_cast<ZoneUseEnum>(0);
+ DataModel::DecodableList<Structs::TwoDCartesianVertexStruct::DecodableType> vertices;
+ Optional<chip::CharSpan> color;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace TwoDCartesianZoneStruct
+namespace ZoneInformationStruct {
+enum class Fields : uint8_t
+{
+ kZoneID = 0,
+ kZoneType = 1,
+ kZoneSource = 2,
+};
+
+struct Type
+{
+public:
+ uint16_t zoneID = static_cast<uint16_t>(0);
+ ZoneTypeEnum zoneType = static_cast<ZoneTypeEnum>(0);
+ ZoneSourceEnum zoneSource = static_cast<ZoneSourceEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ZoneInformationStruct
+namespace ZoneTriggerControlStruct {
+enum class Fields : uint8_t
+{
+ kInitialDuration = 0,
+ kAugmentationDuration = 1,
+ kMaxDuration = 2,
+ kBlindDuration = 3,
+ kSensitivity = 4,
+};
+
+struct Type
+{
+public:
+ uint16_t initialDuration = static_cast<uint16_t>(0);
+ uint16_t augmentationDuration = static_cast<uint16_t>(0);
+ uint32_t maxDuration = static_cast<uint32_t>(0);
+ uint16_t blindDuration = static_cast<uint16_t>(0);
+ Optional<uint8_t> sensitivity;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ZoneTriggerControlStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace CreateTwoDCartesianZone {
+struct Type;
+struct DecodableType;
+} // namespace CreateTwoDCartesianZone
+
+namespace CreateTwoDCartesianZoneResponse {
+struct Type;
+struct DecodableType;
+} // namespace CreateTwoDCartesianZoneResponse
+
+namespace UpdateTwoDCartesianZone {
+struct Type;
+struct DecodableType;
+} // namespace UpdateTwoDCartesianZone
+
+namespace GetTwoDCartesianZone {
+struct Type;
+struct DecodableType;
+} // namespace GetTwoDCartesianZone
+
+namespace GetTwoDCartesianZoneResponse {
+struct Type;
+struct DecodableType;
+} // namespace GetTwoDCartesianZoneResponse
+
+namespace RemoveZone {
+struct Type;
+struct DecodableType;
+} // namespace RemoveZone
+
+} // namespace Commands
+
+namespace Commands {
+namespace CreateTwoDCartesianZone {
+enum class Fields : uint8_t
+{
+ kZone = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CreateTwoDCartesianZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ Structs::TwoDCartesianZoneStruct::Type zone;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ZoneManagement::Commands::CreateTwoDCartesianZoneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CreateTwoDCartesianZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ Structs::TwoDCartesianZoneStruct::DecodableType zone;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CreateTwoDCartesianZone
+namespace CreateTwoDCartesianZoneResponse {
+enum class Fields : uint8_t
+{
+ kZoneID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CreateTwoDCartesianZoneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ uint16_t zoneID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CreateTwoDCartesianZoneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ uint16_t zoneID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CreateTwoDCartesianZoneResponse
+namespace UpdateTwoDCartesianZone {
+enum class Fields : uint8_t
+{
+ kZoneID = 0,
+ kZone = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::UpdateTwoDCartesianZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ uint16_t zoneID = static_cast<uint16_t>(0);
+ Structs::TwoDCartesianZoneStruct::Type zone;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::UpdateTwoDCartesianZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ uint16_t zoneID = static_cast<uint16_t>(0);
+ Structs::TwoDCartesianZoneStruct::DecodableType zone;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace UpdateTwoDCartesianZone
+namespace GetTwoDCartesianZone {
+enum class Fields : uint8_t
+{
+ kZoneID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetTwoDCartesianZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ Optional<DataModel::Nullable<uint16_t>> zoneID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::ZoneManagement::Commands::GetTwoDCartesianZoneResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetTwoDCartesianZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ Optional<DataModel::Nullable<uint16_t>> zoneID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetTwoDCartesianZone
+namespace GetTwoDCartesianZoneResponse {
+enum class Fields : uint8_t
+{
+ kZones = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GetTwoDCartesianZoneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ DataModel::List<const Structs::TwoDCartesianZoneStruct::Type> zones;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GetTwoDCartesianZoneResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ DataModel::DecodableList<Structs::TwoDCartesianZoneStruct::DecodableType> zones;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GetTwoDCartesianZoneResponse
+namespace RemoveZone {
+enum class Fields : uint8_t
+{
+ kZoneID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RemoveZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ uint16_t zoneID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RemoveZone::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ uint16_t zoneID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RemoveZone
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedZoneSources {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ZoneManagement::ZoneSourceEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::ZoneManagement::ZoneSourceEnum>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::ZoneManagement::ZoneSourceEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedZoneSources::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedZoneSources
+namespace Zones {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ZoneManagement::Structs::ZoneInformationStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ZoneManagement::Structs::ZoneInformationStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ZoneManagement::Structs::ZoneInformationStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Zones::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Zones
+namespace Triggers {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::ZoneManagement::Structs::ZoneTriggerControlStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::ZoneManagement::Structs::ZoneTriggerControlStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::ZoneManagement::Structs::ZoneTriggerControlStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Triggers::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Triggers
+namespace Sensitivity {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Sensitivity::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Sensitivity
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedZoneSources::TypeInfo::DecodableType supportedZoneSources;
+ Attributes::Zones::TypeInfo::DecodableType zones;
+ Attributes::Triggers::TypeInfo::DecodableType triggers;
+ Attributes::Sensitivity::TypeInfo::DecodableType sensitivity = static_cast<uint8_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace ZoneTriggered {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kZones = 0,
+ kReason = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ZoneTriggered::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const uint16_t> zones;
+ ZoneEventTriggeredReasonEnum reason = static_cast<ZoneEventTriggeredReasonEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ZoneTriggered::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ DataModel::DecodableList<uint16_t> zones;
+ ZoneEventTriggeredReasonEnum reason = static_cast<ZoneEventTriggeredReasonEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ZoneTriggered
+namespace ZoneStopped {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kZones = 0,
+ kReason = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ZoneStopped::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ DataModel::List<const uint16_t> zones;
+ ZoneEventStoppedReasonEnum reason = static_cast<ZoneEventStoppedReasonEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::ZoneStopped::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::ZoneManagement::Id; }
+
+ DataModel::DecodableList<uint16_t> zones;
+ ZoneEventStoppedReasonEnum reason = static_cast<ZoneEventStoppedReasonEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace ZoneStopped
+} // namespace Events
+} // namespace ZoneManagement
+namespace CameraAvStreamManagement {
+namespace Structs {
+namespace VideoResolutionStruct {
+enum class Fields : uint8_t
+{
+ kWidth = 0,
+ kHeight = 1,
+};
+
+struct Type
+{
+public:
+ uint16_t width = static_cast<uint16_t>(0);
+ uint16_t height = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace VideoResolutionStruct
+namespace VideoStreamStruct {
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+ kStreamUsage = 1,
+ kVideoCodec = 2,
+ kMinFrameRate = 3,
+ kMaxFrameRate = 4,
+ kMinResolution = 5,
+ kMaxResolution = 6,
+ kMinBitRate = 7,
+ kMaxBitRate = 8,
+ kMinFragmentLen = 9,
+ kMaxFragmentLen = 10,
+ kWatermarkEnabled = 11,
+ kOSDEnabled = 12,
+ kReferenceCount = 13,
+};
+
+struct Type
+{
+public:
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ VideoCodecEnum videoCodec = static_cast<VideoCodecEnum>(0);
+ uint16_t minFrameRate = static_cast<uint16_t>(0);
+ uint16_t maxFrameRate = static_cast<uint16_t>(0);
+ Structs::VideoResolutionStruct::Type minResolution;
+ Structs::VideoResolutionStruct::Type maxResolution;
+ uint32_t minBitRate = static_cast<uint32_t>(0);
+ uint32_t maxBitRate = static_cast<uint32_t>(0);
+ uint16_t minFragmentLen = static_cast<uint16_t>(0);
+ uint16_t maxFragmentLen = static_cast<uint16_t>(0);
+ Optional<bool> watermarkEnabled;
+ Optional<bool> OSDEnabled;
+ uint8_t referenceCount = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace VideoStreamStruct
+namespace SnapshotStreamStruct {
+enum class Fields : uint8_t
+{
+ kSnapshotStreamID = 0,
+ kImageCodec = 1,
+ kFrameRate = 2,
+ kBitRate = 3,
+ kMinResolution = 4,
+ kMaxResolution = 5,
+ kQuality = 6,
+ kReferenceCount = 7,
+};
+
+struct Type
+{
+public:
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ ImageCodecEnum imageCodec = static_cast<ImageCodecEnum>(0);
+ uint16_t frameRate = static_cast<uint16_t>(0);
+ uint32_t bitRate = static_cast<uint32_t>(0);
+ Structs::VideoResolutionStruct::Type minResolution;
+ Structs::VideoResolutionStruct::Type maxResolution;
+ uint8_t quality = static_cast<uint8_t>(0);
+ uint8_t referenceCount = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SnapshotStreamStruct
+namespace SnapshotParamsStruct {
+enum class Fields : uint8_t
+{
+ kResolution = 0,
+ kMaxFrameRate = 1,
+ kImageCodec = 2,
+};
+
+struct Type
+{
+public:
+ Structs::VideoResolutionStruct::Type resolution;
+ uint16_t maxFrameRate = static_cast<uint16_t>(0);
+ ImageCodecEnum imageCodec = static_cast<ImageCodecEnum>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SnapshotParamsStruct
+namespace RateDistortionTradeOffPointsStruct {
+enum class Fields : uint8_t
+{
+ kCodec = 0,
+ kResolution = 1,
+ kMinBitRate = 2,
+};
+
+struct Type
+{
+public:
+ VideoCodecEnum codec = static_cast<VideoCodecEnum>(0);
+ Structs::VideoResolutionStruct::Type resolution;
+ uint32_t minBitRate = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace RateDistortionTradeOffPointsStruct
+namespace AudioCapabilitiesStruct {
+enum class Fields : uint8_t
+{
+ kMaxNumberOfChannels = 0,
+ kSupportedCodecs = 1,
+ kSupportedSampleRates = 2,
+ kSupportedBitDepths = 3,
+};
+
+struct Type
+{
+public:
+ uint8_t maxNumberOfChannels = static_cast<uint8_t>(0);
+ DataModel::List<const AudioCodecEnum> supportedCodecs;
+ DataModel::List<const uint32_t> supportedSampleRates;
+ DataModel::List<const uint8_t> supportedBitDepths;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ uint8_t maxNumberOfChannels = static_cast<uint8_t>(0);
+ DataModel::DecodableList<AudioCodecEnum> supportedCodecs;
+ DataModel::DecodableList<uint32_t> supportedSampleRates;
+ DataModel::DecodableList<uint8_t> supportedBitDepths;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace AudioCapabilitiesStruct
+namespace AudioStreamStruct {
+enum class Fields : uint8_t
+{
+ kAudioStreamID = 0,
+ kStreamUsage = 1,
+ kAudioCodec = 2,
+ kChannelCount = 3,
+ kSampleRate = 4,
+ kBitRate = 5,
+ kBitDepth = 6,
+ kReferenceCount = 7,
+};
+
+struct Type
+{
+public:
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ AudioCodecEnum audioCodec = static_cast<AudioCodecEnum>(0);
+ uint8_t channelCount = static_cast<uint8_t>(0);
+ uint32_t sampleRate = static_cast<uint32_t>(0);
+ uint32_t bitRate = static_cast<uint32_t>(0);
+ uint8_t bitDepth = static_cast<uint8_t>(0);
+ uint8_t referenceCount = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace AudioStreamStruct
+namespace VideoSensorParamsStruct {
+enum class Fields : uint8_t
+{
+ kSensorWidth = 0,
+ kSensorHeight = 1,
+ kHDRCapable = 2,
+ kMaxFPS = 3,
+ kMaxHDRFPS = 4,
+};
+
+struct Type
+{
+public:
+ uint16_t sensorWidth = static_cast<uint16_t>(0);
+ uint16_t sensorHeight = static_cast<uint16_t>(0);
+ bool HDRCapable = static_cast<bool>(0);
+ uint16_t maxFPS = static_cast<uint16_t>(0);
+ uint16_t maxHDRFPS = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace VideoSensorParamsStruct
+namespace ViewportStruct = Clusters::detail::Structs::ViewportStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace AudioStreamAllocate {
+struct Type;
+struct DecodableType;
+} // namespace AudioStreamAllocate
+
+namespace AudioStreamAllocateResponse {
+struct Type;
+struct DecodableType;
+} // namespace AudioStreamAllocateResponse
+
+namespace AudioStreamDeallocate {
+struct Type;
+struct DecodableType;
+} // namespace AudioStreamDeallocate
+
+namespace VideoStreamAllocate {
+struct Type;
+struct DecodableType;
+} // namespace VideoStreamAllocate
+
+namespace VideoStreamAllocateResponse {
+struct Type;
+struct DecodableType;
+} // namespace VideoStreamAllocateResponse
+
+namespace VideoStreamModify {
+struct Type;
+struct DecodableType;
+} // namespace VideoStreamModify
+
+namespace VideoStreamDeallocate {
+struct Type;
+struct DecodableType;
+} // namespace VideoStreamDeallocate
+
+namespace SnapshotStreamAllocate {
+struct Type;
+struct DecodableType;
+} // namespace SnapshotStreamAllocate
+
+namespace SnapshotStreamAllocateResponse {
+struct Type;
+struct DecodableType;
+} // namespace SnapshotStreamAllocateResponse
+
+namespace SnapshotStreamDeallocate {
+struct Type;
+struct DecodableType;
+} // namespace SnapshotStreamDeallocate
+
+namespace SetStreamPriorities {
+struct Type;
+struct DecodableType;
+} // namespace SetStreamPriorities
+
+namespace CaptureSnapshot {
+struct Type;
+struct DecodableType;
+} // namespace CaptureSnapshot
+
+namespace CaptureSnapshotResponse {
+struct Type;
+struct DecodableType;
+} // namespace CaptureSnapshotResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace AudioStreamAllocate {
+enum class Fields : uint8_t
+{
+ kStreamUsage = 0,
+ kAudioCodec = 1,
+ kChannelCount = 2,
+ kSampleRate = 3,
+ kBitRate = 4,
+ kBitDepth = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AudioStreamAllocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ AudioCodecEnum audioCodec = static_cast<AudioCodecEnum>(0);
+ uint8_t channelCount = static_cast<uint8_t>(0);
+ uint32_t sampleRate = static_cast<uint32_t>(0);
+ uint32_t bitRate = static_cast<uint32_t>(0);
+ uint8_t bitDepth = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::CameraAvStreamManagement::Commands::AudioStreamAllocateResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AudioStreamAllocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ AudioCodecEnum audioCodec = static_cast<AudioCodecEnum>(0);
+ uint8_t channelCount = static_cast<uint8_t>(0);
+ uint32_t sampleRate = static_cast<uint32_t>(0);
+ uint32_t bitRate = static_cast<uint32_t>(0);
+ uint8_t bitDepth = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AudioStreamAllocate
+namespace AudioStreamAllocateResponse {
+enum class Fields : uint8_t
+{
+ kAudioStreamID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AudioStreamAllocateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AudioStreamAllocateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AudioStreamAllocateResponse
+namespace AudioStreamDeallocate {
+enum class Fields : uint8_t
+{
+ kAudioStreamID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AudioStreamDeallocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AudioStreamDeallocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AudioStreamDeallocate
+namespace VideoStreamAllocate {
+enum class Fields : uint8_t
+{
+ kStreamUsage = 0,
+ kVideoCodec = 1,
+ kMinFrameRate = 2,
+ kMaxFrameRate = 3,
+ kMinResolution = 4,
+ kMaxResolution = 5,
+ kMinBitRate = 6,
+ kMaxBitRate = 7,
+ kMinFragmentLen = 8,
+ kMaxFragmentLen = 9,
+ kWatermarkEnabled = 10,
+ kOSDEnabled = 11,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamAllocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ VideoCodecEnum videoCodec = static_cast<VideoCodecEnum>(0);
+ uint16_t minFrameRate = static_cast<uint16_t>(0);
+ uint16_t maxFrameRate = static_cast<uint16_t>(0);
+ Structs::VideoResolutionStruct::Type minResolution;
+ Structs::VideoResolutionStruct::Type maxResolution;
+ uint32_t minBitRate = static_cast<uint32_t>(0);
+ uint32_t maxBitRate = static_cast<uint32_t>(0);
+ uint16_t minFragmentLen = static_cast<uint16_t>(0);
+ uint16_t maxFragmentLen = static_cast<uint16_t>(0);
+ Optional<bool> watermarkEnabled;
+ Optional<bool> OSDEnabled;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::CameraAvStreamManagement::Commands::VideoStreamAllocateResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamAllocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ VideoCodecEnum videoCodec = static_cast<VideoCodecEnum>(0);
+ uint16_t minFrameRate = static_cast<uint16_t>(0);
+ uint16_t maxFrameRate = static_cast<uint16_t>(0);
+ Structs::VideoResolutionStruct::DecodableType minResolution;
+ Structs::VideoResolutionStruct::DecodableType maxResolution;
+ uint32_t minBitRate = static_cast<uint32_t>(0);
+ uint32_t maxBitRate = static_cast<uint32_t>(0);
+ uint16_t minFragmentLen = static_cast<uint16_t>(0);
+ uint16_t maxFragmentLen = static_cast<uint16_t>(0);
+ Optional<bool> watermarkEnabled;
+ Optional<bool> OSDEnabled;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace VideoStreamAllocate
+namespace VideoStreamAllocateResponse {
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamAllocateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamAllocateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace VideoStreamAllocateResponse
+namespace VideoStreamModify {
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+ kWatermarkEnabled = 1,
+ kOSDEnabled = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamModify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Optional<bool> watermarkEnabled;
+ Optional<bool> OSDEnabled;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamModify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Optional<bool> watermarkEnabled;
+ Optional<bool> OSDEnabled;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace VideoStreamModify
+namespace VideoStreamDeallocate {
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamDeallocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::VideoStreamDeallocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace VideoStreamDeallocate
+namespace SnapshotStreamAllocate {
+enum class Fields : uint8_t
+{
+ kImageCodec = 0,
+ kMaxFrameRate = 1,
+ kBitRate = 2,
+ kMinResolution = 3,
+ kMaxResolution = 4,
+ kQuality = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SnapshotStreamAllocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ ImageCodecEnum imageCodec = static_cast<ImageCodecEnum>(0);
+ uint16_t maxFrameRate = static_cast<uint16_t>(0);
+ uint32_t bitRate = static_cast<uint32_t>(0);
+ Structs::VideoResolutionStruct::Type minResolution;
+ Structs::VideoResolutionStruct::Type maxResolution;
+ uint8_t quality = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::CameraAvStreamManagement::Commands::SnapshotStreamAllocateResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SnapshotStreamAllocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ ImageCodecEnum imageCodec = static_cast<ImageCodecEnum>(0);
+ uint16_t maxFrameRate = static_cast<uint16_t>(0);
+ uint32_t bitRate = static_cast<uint32_t>(0);
+ Structs::VideoResolutionStruct::DecodableType minResolution;
+ Structs::VideoResolutionStruct::DecodableType maxResolution;
+ uint8_t quality = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SnapshotStreamAllocate
+namespace SnapshotStreamAllocateResponse {
+enum class Fields : uint8_t
+{
+ kSnapshotStreamID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SnapshotStreamAllocateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SnapshotStreamAllocateResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SnapshotStreamAllocateResponse
+namespace SnapshotStreamDeallocate {
+enum class Fields : uint8_t
+{
+ kSnapshotStreamID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SnapshotStreamDeallocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SnapshotStreamDeallocate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SnapshotStreamDeallocate
+namespace SetStreamPriorities {
+enum class Fields : uint8_t
+{
+ kStreamPriorities = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SetStreamPriorities::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ DataModel::List<const StreamUsageEnum> streamPriorities;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SetStreamPriorities::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ DataModel::DecodableList<StreamUsageEnum> streamPriorities;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SetStreamPriorities
+namespace CaptureSnapshot {
+enum class Fields : uint8_t
+{
+ kSnapshotStreamID = 0,
+ kRequestedResolution = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CaptureSnapshot::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ Structs::VideoResolutionStruct::Type requestedResolution;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::CameraAvStreamManagement::Commands::CaptureSnapshotResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CaptureSnapshot::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ Structs::VideoResolutionStruct::DecodableType requestedResolution;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CaptureSnapshot
+namespace CaptureSnapshotResponse {
+enum class Fields : uint8_t
+{
+ kData = 0,
+ kImageCodec = 1,
+ kResolution = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CaptureSnapshotResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ chip::ByteSpan data;
+ ImageCodecEnum imageCodec = static_cast<ImageCodecEnum>(0);
+ Structs::VideoResolutionStruct::Type resolution;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CaptureSnapshotResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ chip::ByteSpan data;
+ ImageCodecEnum imageCodec = static_cast<ImageCodecEnum>(0);
+ Structs::VideoResolutionStruct::DecodableType resolution;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CaptureSnapshotResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace MaxConcurrentVideoEncoders {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxConcurrentVideoEncoders::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxConcurrentVideoEncoders
+namespace MaxEncodedPixelRate {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxEncodedPixelRate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxEncodedPixelRate
+namespace VideoSensorParams {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::Structs::VideoSensorParamsStruct::Type;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::Structs::VideoSensorParamsStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::CameraAvStreamManagement::Structs::VideoSensorParamsStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VideoSensorParams::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace VideoSensorParams
+namespace NightVisionCapable {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NightVisionCapable::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NightVisionCapable
+namespace MinViewport {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::Structs::VideoResolutionStruct::Type;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::Structs::VideoResolutionStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::CameraAvStreamManagement::Structs::VideoResolutionStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MinViewport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MinViewport
+namespace RateDistortionTradeOffPoints {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<
+ const chip::app::Clusters::CameraAvStreamManagement::Structs::RateDistortionTradeOffPointsStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::RateDistortionTradeOffPointsStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::RateDistortionTradeOffPointsStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RateDistortionTradeOffPoints::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RateDistortionTradeOffPoints
+namespace MaxContentBufferSize {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxContentBufferSize::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxContentBufferSize
+namespace MicrophoneCapabilities {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::Structs::AudioCapabilitiesStruct::Type;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::Structs::AudioCapabilitiesStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::CameraAvStreamManagement::Structs::AudioCapabilitiesStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MicrophoneCapabilities::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MicrophoneCapabilities
+namespace SpeakerCapabilities {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::Structs::AudioCapabilitiesStruct::Type;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::Structs::AudioCapabilitiesStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::CameraAvStreamManagement::Structs::AudioCapabilitiesStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeakerCapabilities::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeakerCapabilities
+namespace TwoWayTalkSupport {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum;
+ using DecodableArgType = chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TwoWayTalkSupport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TwoWayTalkSupport
+namespace SupportedSnapshotParams {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::CameraAvStreamManagement::Structs::SnapshotParamsStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::SnapshotParamsStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::SnapshotParamsStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedSnapshotParams::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedSnapshotParams
+namespace MaxNetworkBandwidth {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxNetworkBandwidth::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxNetworkBandwidth
+namespace CurrentFrameRate {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentFrameRate::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentFrameRate
+namespace HDRModeEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HDRModeEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HDRModeEnabled
+namespace FabricsUsingCamera {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::FabricIndex>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::FabricIndex>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::FabricIndex> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FabricsUsingCamera::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FabricsUsingCamera
+namespace AllocatedVideoStreams {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::CameraAvStreamManagement::Structs::VideoStreamStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::VideoStreamStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::VideoStreamStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AllocatedVideoStreams::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AllocatedVideoStreams
+namespace AllocatedAudioStreams {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::CameraAvStreamManagement::Structs::AudioStreamStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::AudioStreamStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::AudioStreamStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AllocatedAudioStreams::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AllocatedAudioStreams
+namespace AllocatedSnapshotStreams {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::CameraAvStreamManagement::Structs::SnapshotStreamStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::SnapshotStreamStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvStreamManagement::Structs::SnapshotStreamStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::AllocatedSnapshotStreams::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace AllocatedSnapshotStreams
+namespace RankedVideoStreamPrioritiesList {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::CameraAvStreamManagement::StreamUsageEnum>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::CameraAvStreamManagement::StreamUsageEnum>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::CameraAvStreamManagement::StreamUsageEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RankedVideoStreamPrioritiesList::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RankedVideoStreamPrioritiesList
+namespace SoftRecordingPrivacyModeEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoftRecordingPrivacyModeEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SoftRecordingPrivacyModeEnabled
+namespace SoftLivestreamPrivacyModeEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SoftLivestreamPrivacyModeEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SoftLivestreamPrivacyModeEnabled
+namespace HardPrivacyModeOn {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::HardPrivacyModeOn::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace HardPrivacyModeOn
+namespace NightVision {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum;
+ using DecodableArgType = chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NightVision::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NightVision
+namespace NightVisionIllum {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum;
+ using DecodableArgType = chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NightVisionIllum::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NightVisionIllum
+namespace Viewport {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvStreamManagement::Structs::ViewportStruct::Type;
+ using DecodableType = chip::app::Clusters::CameraAvStreamManagement::Structs::ViewportStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::CameraAvStreamManagement::Structs::ViewportStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Viewport::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Viewport
+namespace SpeakerMuted {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeakerMuted::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeakerMuted
+namespace SpeakerVolumeLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeakerVolumeLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeakerVolumeLevel
+namespace SpeakerMaxLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeakerMaxLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeakerMaxLevel
+namespace SpeakerMinLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SpeakerMinLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SpeakerMinLevel
+namespace MicrophoneMuted {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MicrophoneMuted::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MicrophoneMuted
+namespace MicrophoneVolumeLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MicrophoneVolumeLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MicrophoneVolumeLevel
+namespace MicrophoneMaxLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MicrophoneMaxLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MicrophoneMaxLevel
+namespace MicrophoneMinLevel {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MicrophoneMinLevel::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MicrophoneMinLevel
+namespace MicrophoneAGCEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MicrophoneAGCEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MicrophoneAGCEnabled
+namespace ImageRotation {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ImageRotation::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ImageRotation
+namespace ImageFlipHorizontal {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ImageFlipHorizontal::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ImageFlipHorizontal
+namespace ImageFlipVertical {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ImageFlipVertical::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ImageFlipVertical
+namespace LocalVideoRecordingEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalVideoRecordingEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalVideoRecordingEnabled
+namespace LocalSnapshotRecordingEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocalSnapshotRecordingEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocalSnapshotRecordingEnabled
+namespace StatusLightEnabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StatusLightEnabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StatusLightEnabled
+namespace StatusLightBrightness {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Globals::ThreeLevelAutoEnum;
+ using DecodableType = chip::app::Clusters::Globals::ThreeLevelAutoEnum;
+ using DecodableArgType = chip::app::Clusters::Globals::ThreeLevelAutoEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StatusLightBrightness::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StatusLightBrightness
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MaxConcurrentVideoEncoders::TypeInfo::DecodableType maxConcurrentVideoEncoders = static_cast<uint8_t>(0);
+ Attributes::MaxEncodedPixelRate::TypeInfo::DecodableType maxEncodedPixelRate = static_cast<uint32_t>(0);
+ Attributes::VideoSensorParams::TypeInfo::DecodableType videoSensorParams;
+ Attributes::NightVisionCapable::TypeInfo::DecodableType nightVisionCapable = static_cast<bool>(0);
+ Attributes::MinViewport::TypeInfo::DecodableType minViewport;
+ Attributes::RateDistortionTradeOffPoints::TypeInfo::DecodableType rateDistortionTradeOffPoints;
+ Attributes::MaxContentBufferSize::TypeInfo::DecodableType maxContentBufferSize = static_cast<uint32_t>(0);
+ Attributes::MicrophoneCapabilities::TypeInfo::DecodableType microphoneCapabilities;
+ Attributes::SpeakerCapabilities::TypeInfo::DecodableType speakerCapabilities;
+ Attributes::TwoWayTalkSupport::TypeInfo::DecodableType twoWayTalkSupport =
+ static_cast<chip::app::Clusters::CameraAvStreamManagement::TwoWayTalkSupportTypeEnum>(0);
+ Attributes::SupportedSnapshotParams::TypeInfo::DecodableType supportedSnapshotParams;
+ Attributes::MaxNetworkBandwidth::TypeInfo::DecodableType maxNetworkBandwidth = static_cast<uint32_t>(0);
+ Attributes::CurrentFrameRate::TypeInfo::DecodableType currentFrameRate = static_cast<uint16_t>(0);
+ Attributes::HDRModeEnabled::TypeInfo::DecodableType HDRModeEnabled = static_cast<bool>(0);
+ Attributes::FabricsUsingCamera::TypeInfo::DecodableType fabricsUsingCamera;
+ Attributes::AllocatedVideoStreams::TypeInfo::DecodableType allocatedVideoStreams;
+ Attributes::AllocatedAudioStreams::TypeInfo::DecodableType allocatedAudioStreams;
+ Attributes::AllocatedSnapshotStreams::TypeInfo::DecodableType allocatedSnapshotStreams;
+ Attributes::RankedVideoStreamPrioritiesList::TypeInfo::DecodableType rankedVideoStreamPrioritiesList;
+ Attributes::SoftRecordingPrivacyModeEnabled::TypeInfo::DecodableType softRecordingPrivacyModeEnabled = static_cast<bool>(0);
+ Attributes::SoftLivestreamPrivacyModeEnabled::TypeInfo::DecodableType softLivestreamPrivacyModeEnabled =
+ static_cast<bool>(0);
+ Attributes::HardPrivacyModeOn::TypeInfo::DecodableType hardPrivacyModeOn = static_cast<bool>(0);
+ Attributes::NightVision::TypeInfo::DecodableType nightVision =
+ static_cast<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>(0);
+ Attributes::NightVisionIllum::TypeInfo::DecodableType nightVisionIllum =
+ static_cast<chip::app::Clusters::CameraAvStreamManagement::TriStateAutoEnum>(0);
+ Attributes::Viewport::TypeInfo::DecodableType viewport;
+ Attributes::SpeakerMuted::TypeInfo::DecodableType speakerMuted = static_cast<bool>(0);
+ Attributes::SpeakerVolumeLevel::TypeInfo::DecodableType speakerVolumeLevel = static_cast<uint8_t>(0);
+ Attributes::SpeakerMaxLevel::TypeInfo::DecodableType speakerMaxLevel = static_cast<uint8_t>(0);
+ Attributes::SpeakerMinLevel::TypeInfo::DecodableType speakerMinLevel = static_cast<uint8_t>(0);
+ Attributes::MicrophoneMuted::TypeInfo::DecodableType microphoneMuted = static_cast<bool>(0);
+ Attributes::MicrophoneVolumeLevel::TypeInfo::DecodableType microphoneVolumeLevel = static_cast<uint8_t>(0);
+ Attributes::MicrophoneMaxLevel::TypeInfo::DecodableType microphoneMaxLevel = static_cast<uint8_t>(0);
+ Attributes::MicrophoneMinLevel::TypeInfo::DecodableType microphoneMinLevel = static_cast<uint8_t>(0);
+ Attributes::MicrophoneAGCEnabled::TypeInfo::DecodableType microphoneAGCEnabled = static_cast<bool>(0);
+ Attributes::ImageRotation::TypeInfo::DecodableType imageRotation = static_cast<uint16_t>(0);
+ Attributes::ImageFlipHorizontal::TypeInfo::DecodableType imageFlipHorizontal = static_cast<bool>(0);
+ Attributes::ImageFlipVertical::TypeInfo::DecodableType imageFlipVertical = static_cast<bool>(0);
+ Attributes::LocalVideoRecordingEnabled::TypeInfo::DecodableType localVideoRecordingEnabled = static_cast<bool>(0);
+ Attributes::LocalSnapshotRecordingEnabled::TypeInfo::DecodableType localSnapshotRecordingEnabled = static_cast<bool>(0);
+ Attributes::StatusLightEnabled::TypeInfo::DecodableType statusLightEnabled = static_cast<bool>(0);
+ Attributes::StatusLightBrightness::TypeInfo::DecodableType statusLightBrightness =
+ static_cast<chip::app::Clusters::Globals::ThreeLevelAutoEnum>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace VideoStreamChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+ kStreamUsage = 1,
+ kVideoCodec = 2,
+ kMinFrameRate = 3,
+ kMaxFrameRate = 4,
+ kMinResolution = 5,
+ kMaxResolution = 6,
+ kMinBitRate = 7,
+ kMaxBitRate = 8,
+ kMinFragmentLen = 9,
+ kMaxFragmentLen = 10,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::VideoStreamChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Optional<StreamUsageEnum> streamUsage;
+ Optional<VideoCodecEnum> videoCodec;
+ Optional<uint16_t> minFrameRate;
+ Optional<uint16_t> maxFrameRate;
+ Optional<Structs::VideoResolutionStruct::Type> minResolution;
+ Optional<Structs::VideoResolutionStruct::Type> maxResolution;
+ Optional<uint32_t> minBitRate;
+ Optional<uint32_t> maxBitRate;
+ Optional<uint16_t> minFragmentLen;
+ Optional<uint16_t> maxFragmentLen;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::VideoStreamChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Optional<StreamUsageEnum> streamUsage;
+ Optional<VideoCodecEnum> videoCodec;
+ Optional<uint16_t> minFrameRate;
+ Optional<uint16_t> maxFrameRate;
+ Optional<Structs::VideoResolutionStruct::DecodableType> minResolution;
+ Optional<Structs::VideoResolutionStruct::DecodableType> maxResolution;
+ Optional<uint32_t> minBitRate;
+ Optional<uint32_t> maxBitRate;
+ Optional<uint16_t> minFragmentLen;
+ Optional<uint16_t> maxFragmentLen;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace VideoStreamChanged
+namespace AudioStreamChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kAudioStreamID = 0,
+ kStreamUsage = 1,
+ kAudioCodec = 2,
+ kChannelCount = 3,
+ kSampleRate = 4,
+ kBitRate = 5,
+ kBitDepth = 6,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AudioStreamChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+ Optional<StreamUsageEnum> streamUsage;
+ Optional<AudioCodecEnum> audioCodec;
+ Optional<uint8_t> channelCount;
+ Optional<uint32_t> sampleRate;
+ Optional<uint32_t> bitRate;
+ Optional<uint8_t> bitDepth;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::AudioStreamChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+ Optional<StreamUsageEnum> streamUsage;
+ Optional<AudioCodecEnum> audioCodec;
+ Optional<uint8_t> channelCount;
+ Optional<uint32_t> sampleRate;
+ Optional<uint32_t> bitRate;
+ Optional<uint8_t> bitDepth;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace AudioStreamChanged
+namespace SnapshotStreamChanged {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kSnapshotStreamID = 0,
+ kImageCodec = 1,
+ kFrameRate = 2,
+ kBitRate = 3,
+ kMinResolution = 4,
+ kMaxResolution = 5,
+ kQuality = 6,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SnapshotStreamChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ Optional<ImageCodecEnum> imageCodec;
+ Optional<uint16_t> frameRate;
+ Optional<uint32_t> bitRate;
+ Optional<Structs::VideoResolutionStruct::Type> minResolution;
+ Optional<Structs::VideoResolutionStruct::Type> maxResolution;
+ Optional<uint8_t> quality;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::SnapshotStreamChanged::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvStreamManagement::Id; }
+
+ uint16_t snapshotStreamID = static_cast<uint16_t>(0);
+ Optional<ImageCodecEnum> imageCodec;
+ Optional<uint16_t> frameRate;
+ Optional<uint32_t> bitRate;
+ Optional<Structs::VideoResolutionStruct::DecodableType> minResolution;
+ Optional<Structs::VideoResolutionStruct::DecodableType> maxResolution;
+ Optional<uint8_t> quality;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace SnapshotStreamChanged
+} // namespace Events
+} // namespace CameraAvStreamManagement
+namespace CameraAvSettingsUserLevelManagement {
+namespace Structs {
+namespace MPTZStruct {
+enum class Fields : uint8_t
+{
+ kPan = 0,
+ kTilt = 1,
+ kZoom = 2,
+};
+
+struct Type
+{
+public:
+ Optional<int16_t> pan;
+ Optional<int16_t> tilt;
+ Optional<uint8_t> zoom;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MPTZStruct
+namespace MPTZPresetStruct {
+enum class Fields : uint8_t
+{
+ kPresetID = 0,
+ kName = 1,
+ kSettings = 2,
+};
+
+struct Type
+{
+public:
+ uint8_t presetID = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+ Structs::MPTZStruct::Type settings;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace MPTZPresetStruct
+namespace ViewportStruct = Clusters::detail::Structs::ViewportStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace MPTZSetPosition {
+struct Type;
+struct DecodableType;
+} // namespace MPTZSetPosition
+
+namespace MPTZRelativeMove {
+struct Type;
+struct DecodableType;
+} // namespace MPTZRelativeMove
+
+namespace MPTZMoveToPreset {
+struct Type;
+struct DecodableType;
+} // namespace MPTZMoveToPreset
+
+namespace MPTZSavePreset {
+struct Type;
+struct DecodableType;
+} // namespace MPTZSavePreset
+
+namespace MPTZRemovePreset {
+struct Type;
+struct DecodableType;
+} // namespace MPTZRemovePreset
+
+namespace DPTZSetViewport {
+struct Type;
+struct DecodableType;
+} // namespace DPTZSetViewport
+
+namespace DPTZRelativeMove {
+struct Type;
+struct DecodableType;
+} // namespace DPTZRelativeMove
+
+} // namespace Commands
+
+namespace Commands {
+namespace MPTZSetPosition {
+enum class Fields : uint8_t
+{
+ kPan = 0,
+ kTilt = 1,
+ kZoom = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MPTZSetPosition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ Optional<int16_t> pan;
+ Optional<int16_t> tilt;
+ Optional<uint8_t> zoom;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MPTZSetPosition::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ Optional<int16_t> pan;
+ Optional<int16_t> tilt;
+ Optional<uint8_t> zoom;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MPTZSetPosition
+namespace MPTZRelativeMove {
+enum class Fields : uint8_t
+{
+ kPanDelta = 0,
+ kTiltDelta = 1,
+ kZoomDelta = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MPTZRelativeMove::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ Optional<int16_t> panDelta;
+ Optional<int16_t> tiltDelta;
+ Optional<int8_t> zoomDelta;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MPTZRelativeMove::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ Optional<int16_t> panDelta;
+ Optional<int16_t> tiltDelta;
+ Optional<int8_t> zoomDelta;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MPTZRelativeMove
+namespace MPTZMoveToPreset {
+enum class Fields : uint8_t
+{
+ kPresetID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MPTZMoveToPreset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint8_t presetID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MPTZMoveToPreset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint8_t presetID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MPTZMoveToPreset
+namespace MPTZSavePreset {
+enum class Fields : uint8_t
+{
+ kPresetID = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MPTZSavePreset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ Optional<uint8_t> presetID;
+ chip::CharSpan name;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MPTZSavePreset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ Optional<uint8_t> presetID;
+ chip::CharSpan name;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MPTZSavePreset
+namespace MPTZRemovePreset {
+enum class Fields : uint8_t
+{
+ kPresetID = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::MPTZRemovePreset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint8_t presetID = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::MPTZRemovePreset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint8_t presetID = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace MPTZRemovePreset
+namespace DPTZSetViewport {
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+ kViewport = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DPTZSetViewport::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Structs::ViewportStruct::Type viewport;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DPTZSetViewport::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Structs::ViewportStruct::DecodableType viewport;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DPTZSetViewport
+namespace DPTZRelativeMove {
+enum class Fields : uint8_t
+{
+ kVideoStreamID = 0,
+ kDeltaX = 1,
+ kDeltaY = 2,
+ kZoomDelta = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::DPTZRelativeMove::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Optional<int16_t> deltaX;
+ Optional<int16_t> deltaY;
+ Optional<int8_t> zoomDelta;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::DPTZRelativeMove::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ Optional<int16_t> deltaX;
+ Optional<int16_t> deltaY;
+ Optional<int8_t> zoomDelta;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace DPTZRelativeMove
+} // namespace Commands
+
+namespace Attributes {
+
+namespace MPTZPosition {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::CameraAvSettingsUserLevelManagement::Structs::MPTZStruct::Type;
+ using DecodableType = chip::app::Clusters::CameraAvSettingsUserLevelManagement::Structs::MPTZStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Structs::MPTZStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MPTZPosition::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MPTZPosition
+namespace MaxPresets {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MaxPresets::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MaxPresets
+namespace MPTZPresets {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::CameraAvSettingsUserLevelManagement::Structs::MPTZPresetStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvSettingsUserLevelManagement::Structs::MPTZPresetStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::CameraAvSettingsUserLevelManagement::Structs::MPTZPresetStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MPTZPresets::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MPTZPresets
+namespace DPTZRelativeMove {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const uint16_t>;
+ using DecodableType = chip::app::DataModel::DecodableList<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DPTZRelativeMove::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DPTZRelativeMove
+namespace ZoomMax {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ZoomMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ZoomMax
+namespace TiltMin {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TiltMin::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TiltMin
+namespace TiltMax {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TiltMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace TiltMax
+namespace PanMin {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PanMin::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PanMin
+namespace PanMax {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::PanMax::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace PanMax
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::CameraAvSettingsUserLevelManagement::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::MPTZPosition::TypeInfo::DecodableType MPTZPosition;
+ Attributes::MaxPresets::TypeInfo::DecodableType maxPresets = static_cast<uint8_t>(0);
+ Attributes::MPTZPresets::TypeInfo::DecodableType MPTZPresets;
+ Attributes::DPTZRelativeMove::TypeInfo::DecodableType DPTZRelativeMove;
+ Attributes::ZoomMax::TypeInfo::DecodableType zoomMax = static_cast<uint8_t>(0);
+ Attributes::TiltMin::TypeInfo::DecodableType tiltMin = static_cast<int16_t>(0);
+ Attributes::TiltMax::TypeInfo::DecodableType tiltMax = static_cast<int16_t>(0);
+ Attributes::PanMin::TypeInfo::DecodableType panMin = static_cast<int16_t>(0);
+ Attributes::PanMax::TypeInfo::DecodableType panMax = static_cast<int16_t>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace CameraAvSettingsUserLevelManagement
+namespace WebRTCTransportProvider {
+namespace Structs {
+namespace ICEServerStruct = Clusters::detail::Structs::ICEServerStruct;
+namespace WebRTCSessionStruct = Clusters::detail::Structs::WebRTCSessionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace SolicitOffer {
+struct Type;
+struct DecodableType;
+} // namespace SolicitOffer
+
+namespace SolicitOfferResponse {
+struct Type;
+struct DecodableType;
+} // namespace SolicitOfferResponse
+
+namespace ProvideOffer {
+struct Type;
+struct DecodableType;
+} // namespace ProvideOffer
+
+namespace ProvideOfferResponse {
+struct Type;
+struct DecodableType;
+} // namespace ProvideOfferResponse
+
+namespace ProvideAnswer {
+struct Type;
+struct DecodableType;
+} // namespace ProvideAnswer
+
+namespace ProvideICECandidate {
+struct Type;
+struct DecodableType;
+} // namespace ProvideICECandidate
+
+namespace EndSession {
+struct Type;
+struct DecodableType;
+} // namespace EndSession
+
+} // namespace Commands
+
+namespace Commands {
+namespace SolicitOffer {
+enum class Fields : uint8_t
+{
+ kStreamUsage = 0,
+ kVideoStreamID = 1,
+ kAudioStreamID = 2,
+ kICEServers = 3,
+ kICETransportPolicy = 4,
+ kMetadataOptions = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SolicitOffer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ Optional<DataModel::Nullable<uint16_t>> videoStreamID;
+ Optional<DataModel::Nullable<uint16_t>> audioStreamID;
+ Optional<DataModel::List<const Structs::ICEServerStruct::Type>> ICEServers;
+ Optional<chip::CharSpan> ICETransportPolicy;
+ Optional<chip::BitMask<WebRTCMetadataOptions>> metadataOptions;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::WebRTCTransportProvider::Commands::SolicitOfferResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SolicitOffer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ Optional<DataModel::Nullable<uint16_t>> videoStreamID;
+ Optional<DataModel::Nullable<uint16_t>> audioStreamID;
+ Optional<DataModel::DecodableList<Structs::ICEServerStruct::DecodableType>> ICEServers;
+ Optional<chip::CharSpan> ICETransportPolicy;
+ Optional<chip::BitMask<WebRTCMetadataOptions>> metadataOptions;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SolicitOffer
+namespace SolicitOfferResponse {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kDeferredOffer = 1,
+ kVideoStreamID = 2,
+ kAudioStreamID = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SolicitOfferResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ bool deferredOffer = static_cast<bool>(0);
+ Optional<DataModel::Nullable<uint16_t>> videoStreamID;
+ Optional<DataModel::Nullable<uint16_t>> audioStreamID;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SolicitOfferResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ bool deferredOffer = static_cast<bool>(0);
+ Optional<DataModel::Nullable<uint16_t>> videoStreamID;
+ Optional<DataModel::Nullable<uint16_t>> audioStreamID;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SolicitOfferResponse
+namespace ProvideOffer {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kSdp = 1,
+ kStreamUsage = 2,
+ kVideoStreamID = 3,
+ kAudioStreamID = 4,
+ kICEServers = 5,
+ kICETransportPolicy = 6,
+ kMetadataOptions = 7,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ProvideOffer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ DataModel::Nullable<uint16_t> webRTCSessionID;
+ chip::CharSpan sdp;
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ Optional<DataModel::Nullable<uint16_t>> videoStreamID;
+ Optional<DataModel::Nullable<uint16_t>> audioStreamID;
+ Optional<DataModel::List<const Structs::ICEServerStruct::Type>> ICEServers;
+ Optional<chip::CharSpan> ICETransportPolicy;
+ Optional<chip::BitMask<WebRTCMetadataOptions>> metadataOptions;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::WebRTCTransportProvider::Commands::ProvideOfferResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ProvideOffer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ DataModel::Nullable<uint16_t> webRTCSessionID;
+ chip::CharSpan sdp;
+ StreamUsageEnum streamUsage = static_cast<StreamUsageEnum>(0);
+ Optional<DataModel::Nullable<uint16_t>> videoStreamID;
+ Optional<DataModel::Nullable<uint16_t>> audioStreamID;
+ Optional<DataModel::DecodableList<Structs::ICEServerStruct::DecodableType>> ICEServers;
+ Optional<chip::CharSpan> ICETransportPolicy;
+ Optional<chip::BitMask<WebRTCMetadataOptions>> metadataOptions;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ProvideOffer
+namespace ProvideOfferResponse {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kVideoStreamID = 1,
+ kAudioStreamID = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ProvideOfferResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ProvideOfferResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ uint16_t videoStreamID = static_cast<uint16_t>(0);
+ uint16_t audioStreamID = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ProvideOfferResponse
+namespace ProvideAnswer {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kSdp = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ProvideAnswer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan sdp;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ProvideAnswer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan sdp;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ProvideAnswer
+namespace ProvideICECandidate {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kICECandidate = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ProvideICECandidate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan ICECandidate;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ProvideICECandidate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan ICECandidate;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ProvideICECandidate
+namespace EndSession {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kReason = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::EndSession::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ WebRTCEndReasonEnum reason = static_cast<WebRTCEndReasonEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::EndSession::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ WebRTCEndReasonEnum reason = static_cast<WebRTCEndReasonEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace EndSession
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CurrentSessions {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::WebRTCTransportProvider::Structs::WebRTCSessionStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::WebRTCTransportProvider::Structs::WebRTCSessionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::WebRTCTransportProvider::Structs::WebRTCSessionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentSessions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentSessions
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportProvider::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CurrentSessions::TypeInfo::DecodableType currentSessions;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace WebRTCTransportProvider
+namespace WebRTCTransportRequestor {
+namespace Structs {
+namespace ICEServerStruct = Clusters::detail::Structs::ICEServerStruct;
+namespace WebRTCSessionStruct = Clusters::detail::Structs::WebRTCSessionStruct;
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Offer {
+struct Type;
+struct DecodableType;
+} // namespace Offer
+
+namespace Answer {
+struct Type;
+struct DecodableType;
+} // namespace Answer
+
+namespace ICECandidate {
+struct Type;
+struct DecodableType;
+} // namespace ICECandidate
+
+namespace End {
+struct Type;
+struct DecodableType;
+} // namespace End
+
+} // namespace Commands
+
+namespace Commands {
+namespace Offer {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kSdp = 1,
+ kICEServers = 2,
+ kICETransportPolicy = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Offer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan sdp;
+ Optional<DataModel::List<const Structs::ICEServerStruct::Type>> ICEServers;
+ Optional<chip::CharSpan> ICETransportPolicy;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Offer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan sdp;
+ Optional<DataModel::DecodableList<Structs::ICEServerStruct::DecodableType>> ICEServers;
+ Optional<chip::CharSpan> ICETransportPolicy;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Offer
+namespace Answer {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kSdp = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Answer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan sdp;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Answer::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan sdp;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Answer
+namespace ICECandidate {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kICECandidate = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ICECandidate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan ICECandidate;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ICECandidate::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ chip::CharSpan ICECandidate;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ICECandidate
+namespace End {
+enum class Fields : uint8_t
+{
+ kWebRTCSessionID = 0,
+ kReason = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::End::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ WebRTCEndReasonEnum reason = static_cast<WebRTCEndReasonEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::End::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ uint16_t webRTCSessionID = static_cast<uint16_t>(0);
+ WebRTCEndReasonEnum reason = static_cast<WebRTCEndReasonEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace End
+} // namespace Commands
+
+namespace Attributes {
+
+namespace CurrentSessions {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::WebRTCTransportRequestor::Structs::WebRTCSessionStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::WebRTCTransportRequestor::Structs::WebRTCSessionStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::WebRTCTransportRequestor::Structs::WebRTCSessionStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CurrentSessions::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace CurrentSessions
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::WebRTCTransportRequestor::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::CurrentSessions::TypeInfo::DecodableType currentSessions;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace WebRTCTransportRequestor
+namespace Chime {
+namespace Structs {
+namespace ChimeSoundStruct {
+enum class Fields : uint8_t
+{
+ kChimeID = 0,
+ kName = 1,
+};
+
+struct Type
+{
+public:
+ uint8_t chimeID = static_cast<uint8_t>(0);
+ chip::CharSpan name;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace ChimeSoundStruct
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace PlayChimeSound {
+struct Type;
+struct DecodableType;
+} // namespace PlayChimeSound
+
+} // namespace Commands
+
+namespace Commands {
+namespace PlayChimeSound {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::PlayChimeSound::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::PlayChimeSound::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace PlayChimeSound
+} // namespace Commands
+
+namespace Attributes {
+
+namespace InstalledChimeSounds {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::Chime::Structs::ChimeSoundStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::Chime::Structs::ChimeSoundStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::Chime::Structs::ChimeSoundStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::InstalledChimeSounds::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace InstalledChimeSounds
+namespace ActiveChimeID {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ActiveChimeID::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ActiveChimeID
+namespace Enabled {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Enabled::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Enabled
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::Chime::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::InstalledChimeSounds::TypeInfo::DecodableType installedChimeSounds;
+ Attributes::ActiveChimeID::TypeInfo::DecodableType activeChimeID = static_cast<uint8_t>(0);
+ Attributes::Enabled::TypeInfo::DecodableType enabled = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace Chime
+namespace EcosystemInformation {
+namespace Structs {
+namespace DeviceTypeStruct = Clusters::detail::Structs::DeviceTypeStruct;
+namespace EcosystemDeviceStruct {
+enum class Fields : uint8_t
+{
+ kDeviceName = 0,
+ kDeviceNameLastEdit = 1,
+ kBridgedEndpoint = 2,
+ kOriginalEndpoint = 3,
+ kDeviceTypes = 4,
+ kUniqueLocationIDs = 5,
+ kUniqueLocationIDsLastEdit = 6,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ Optional<chip::CharSpan> deviceName;
+ Optional<uint64_t> deviceNameLastEdit;
+ chip::EndpointId bridgedEndpoint = static_cast<chip::EndpointId>(0);
+ chip::EndpointId originalEndpoint = static_cast<chip::EndpointId>(0);
+ DataModel::List<const Structs::DeviceTypeStruct::Type> deviceTypes;
+ DataModel::List<const chip::CharSpan> uniqueLocationIDs;
+ uint64_t uniqueLocationIDsLastEdit = static_cast<uint64_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+struct DecodableType
+{
+public:
+ Optional<chip::CharSpan> deviceName;
+ Optional<uint64_t> deviceNameLastEdit;
+ chip::EndpointId bridgedEndpoint = static_cast<chip::EndpointId>(0);
+ chip::EndpointId originalEndpoint = static_cast<chip::EndpointId>(0);
+ DataModel::DecodableList<Structs::DeviceTypeStruct::DecodableType> deviceTypes;
+ DataModel::DecodableList<chip::CharSpan> uniqueLocationIDs;
+ uint64_t uniqueLocationIDsLastEdit = static_cast<uint64_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+};
+
+} // namespace EcosystemDeviceStruct
+namespace EcosystemLocationStruct {
+enum class Fields : uint8_t
+{
+ kUniqueLocationID = 0,
+ kLocationDescriptor = 1,
+ kLocationDescriptorLastEdit = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ chip::CharSpan uniqueLocationID;
+ Globals::Structs::LocationDescriptorStruct::Type locationDescriptor;
+ uint64_t locationDescriptorLastEdit = static_cast<uint64_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+using DecodableType = Type;
+
+} // namespace EcosystemLocationStruct
+} // namespace Structs
+
+namespace Attributes {
+
+namespace DeviceDirectory {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::EcosystemInformation::Structs::EcosystemDeviceStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::EcosystemInformation::Structs::EcosystemDeviceStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::EcosystemInformation::Structs::EcosystemDeviceStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::DeviceDirectory::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace DeviceDirectory
+namespace LocationDirectory {
+struct TypeInfo
+{
+ using Type =
+ chip::app::DataModel::List<const chip::app::Clusters::EcosystemInformation::Structs::EcosystemLocationStruct::Type>;
+ using DecodableType = chip::app::DataModel::DecodableList<
+ chip::app::Clusters::EcosystemInformation::Structs::EcosystemLocationStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::EcosystemInformation::Structs::EcosystemLocationStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LocationDirectory::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace LocationDirectory
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::EcosystemInformation::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::DeviceDirectory::TypeInfo::DecodableType deviceDirectory;
+ Attributes::LocationDirectory::TypeInfo::DecodableType locationDirectory;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace EcosystemInformation
+namespace CommissionerControl {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace RequestCommissioningApproval {
+struct Type;
+struct DecodableType;
+} // namespace RequestCommissioningApproval
+
+namespace CommissionNode {
+struct Type;
+struct DecodableType;
+} // namespace CommissionNode
+
+namespace ReverseOpenCommissioningWindow {
+struct Type;
+struct DecodableType;
+} // namespace ReverseOpenCommissioningWindow
+
+} // namespace Commands
+
+namespace Commands {
+namespace RequestCommissioningApproval {
+enum class Fields : uint8_t
+{
+ kRequestID = 0,
+ kVendorID = 1,
+ kProductID = 2,
+ kLabel = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::RequestCommissioningApproval::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint64_t requestID = static_cast<uint64_t>(0);
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ uint16_t productID = static_cast<uint16_t>(0);
+ Optional<chip::CharSpan> label;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::RequestCommissioningApproval::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint64_t requestID = static_cast<uint64_t>(0);
+ chip::VendorId vendorID = static_cast<chip::VendorId>(0);
+ uint16_t productID = static_cast<uint16_t>(0);
+ Optional<chip::CharSpan> label;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace RequestCommissioningApproval
+namespace CommissionNode {
+enum class Fields : uint8_t
+{
+ kRequestID = 0,
+ kResponseTimeoutSeconds = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::CommissionNode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint64_t requestID = static_cast<uint64_t>(0);
+ uint16_t responseTimeoutSeconds = static_cast<uint16_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::CommissionerControl::Commands::ReverseOpenCommissioningWindow::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::CommissionNode::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint64_t requestID = static_cast<uint64_t>(0);
+ uint16_t responseTimeoutSeconds = static_cast<uint16_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace CommissionNode
+namespace ReverseOpenCommissioningWindow {
+enum class Fields : uint8_t
+{
+ kCommissioningTimeout = 0,
+ kPAKEPasscodeVerifier = 1,
+ kDiscriminator = 2,
+ kIterations = 3,
+ kSalt = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::ReverseOpenCommissioningWindow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint16_t commissioningTimeout = static_cast<uint16_t>(0);
+ chip::ByteSpan PAKEPasscodeVerifier;
+ uint16_t discriminator = static_cast<uint16_t>(0);
+ uint32_t iterations = static_cast<uint32_t>(0);
+ chip::ByteSpan salt;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::ReverseOpenCommissioningWindow::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint16_t commissioningTimeout = static_cast<uint16_t>(0);
+ chip::ByteSpan PAKEPasscodeVerifier;
+ uint16_t discriminator = static_cast<uint16_t>(0);
+ uint32_t iterations = static_cast<uint32_t>(0);
+ chip::ByteSpan salt;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace ReverseOpenCommissioningWindow
+} // namespace Commands
+
+namespace Attributes {
+
+namespace SupportedDeviceCategories {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::SupportedDeviceCategories::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace SupportedDeviceCategories
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::SupportedDeviceCategories::TypeInfo::DecodableType supportedDeviceCategories =
+ static_cast<chip::BitMask<chip::app::Clusters::CommissionerControl::SupportedDeviceCategoryBitmap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace CommissioningRequestResult {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kRequestID = 0,
+ kClientNodeID = 1,
+ kStatusCode = 2,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::CommissioningRequestResult::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+ static constexpr bool kIsFabricScoped = true;
+
+ uint64_t requestID = static_cast<uint64_t>(0);
+ chip::NodeId clientNodeID = static_cast<chip::NodeId>(0);
+ uint8_t statusCode = static_cast<uint8_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::CommissioningRequestResult::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::CommissionerControl::Id; }
+
+ uint64_t requestID = static_cast<uint64_t>(0);
+ chip::NodeId clientNodeID = static_cast<chip::NodeId>(0);
+ uint8_t statusCode = static_cast<uint8_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace CommissioningRequestResult
+} // namespace Events
+} // namespace CommissionerControl
+namespace UnitTesting {
+namespace Structs {
+namespace SimpleStruct {
+enum class Fields : uint8_t
+{
+ kA = 0,
+ kB = 1,
+ kC = 2,
+ kD = 3,
+ kE = 4,
+ kF = 5,
+ kG = 6,
+ kH = 7,
+ kI = 8,
+};
+
+struct Type
+{
+public:
+ uint8_t a = static_cast<uint8_t>(0);
+ bool b = static_cast<bool>(0);
+ SimpleEnum c = static_cast<SimpleEnum>(0);
+ chip::ByteSpan d;
+ chip::CharSpan e;
+ chip::BitMask<SimpleBitmap> f = static_cast<chip::BitMask<SimpleBitmap>>(0);
+ float g = static_cast<float>(0);
+ double h = static_cast<double>(0);
+ Optional<Globals::TestGlobalEnum> i;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace SimpleStruct
+namespace TestFabricScoped {
+enum class Fields : uint8_t
+{
+ kFabricSensitiveInt8u = 1,
+ kOptionalFabricSensitiveInt8u = 2,
+ kNullableFabricSensitiveInt8u = 3,
+ kNullableOptionalFabricSensitiveInt8u = 4,
+ kFabricSensitiveCharString = 5,
+ kFabricSensitiveStruct = 6,
+ kFabricSensitiveInt8uList = 7,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ uint8_t fabricSensitiveInt8u = static_cast<uint8_t>(0);
+ Optional<uint8_t> optionalFabricSensitiveInt8u;
+ DataModel::Nullable<uint8_t> nullableFabricSensitiveInt8u;
+ Optional<DataModel::Nullable<uint8_t>> nullableOptionalFabricSensitiveInt8u;
+ chip::CharSpan fabricSensitiveCharString;
+ Structs::SimpleStruct::Type fabricSensitiveStruct;
+ DataModel::List<const uint8_t> fabricSensitiveInt8uList;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+
+ CHIP_ERROR EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+ CHIP_ERROR EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const;
+
+private:
+ CHIP_ERROR DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const;
+};
+
+struct DecodableType
+{
+public:
+ uint8_t fabricSensitiveInt8u = static_cast<uint8_t>(0);
+ Optional<uint8_t> optionalFabricSensitiveInt8u;
+ DataModel::Nullable<uint8_t> nullableFabricSensitiveInt8u;
+ Optional<DataModel::Nullable<uint8_t>> nullableOptionalFabricSensitiveInt8u;
+ chip::CharSpan fabricSensitiveCharString;
+ Structs::SimpleStruct::DecodableType fabricSensitiveStruct;
+ DataModel::DecodableList<uint8_t> fabricSensitiveInt8uList;
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = true;
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; }
+};
+
+} // namespace TestFabricScoped
+namespace NullablesAndOptionalsStruct {
+enum class Fields : uint8_t
+{
+ kNullableInt = 0,
+ kOptionalInt = 1,
+ kNullableOptionalInt = 2,
+ kNullableString = 3,
+ kOptionalString = 4,
+ kNullableOptionalString = 5,
+ kNullableStruct = 6,
+ kOptionalStruct = 7,
+ kNullableOptionalStruct = 8,
+ kNullableList = 9,
+ kOptionalList = 10,
+ kNullableOptionalList = 11,
+};
+
+struct Type
+{
+public:
+ DataModel::Nullable<uint16_t> nullableInt;
+ Optional<uint16_t> optionalInt;
+ Optional<DataModel::Nullable<uint16_t>> nullableOptionalInt;
+ DataModel::Nullable<chip::CharSpan> nullableString;
+ Optional<chip::CharSpan> optionalString;
+ Optional<DataModel::Nullable<chip::CharSpan>> nullableOptionalString;
+ DataModel::Nullable<Structs::SimpleStruct::Type> nullableStruct;
+ Optional<Structs::SimpleStruct::Type> optionalStruct;
+ Optional<DataModel::Nullable<Structs::SimpleStruct::Type>> nullableOptionalStruct;
+ DataModel::Nullable<DataModel::List<const SimpleEnum>> nullableList;
+ Optional<DataModel::List<const SimpleEnum>> optionalList;
+ Optional<DataModel::Nullable<DataModel::List<const SimpleEnum>>> nullableOptionalList;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::Nullable<uint16_t> nullableInt;
+ Optional<uint16_t> optionalInt;
+ Optional<DataModel::Nullable<uint16_t>> nullableOptionalInt;
+ DataModel::Nullable<chip::CharSpan> nullableString;
+ Optional<chip::CharSpan> optionalString;
+ Optional<DataModel::Nullable<chip::CharSpan>> nullableOptionalString;
+ DataModel::Nullable<Structs::SimpleStruct::DecodableType> nullableStruct;
+ Optional<Structs::SimpleStruct::DecodableType> optionalStruct;
+ Optional<DataModel::Nullable<Structs::SimpleStruct::DecodableType>> nullableOptionalStruct;
+ DataModel::Nullable<DataModel::DecodableList<SimpleEnum>> nullableList;
+ Optional<DataModel::DecodableList<SimpleEnum>> optionalList;
+ Optional<DataModel::Nullable<DataModel::DecodableList<SimpleEnum>>> nullableOptionalList;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace NullablesAndOptionalsStruct
+namespace NestedStruct {
+enum class Fields : uint8_t
+{
+ kA = 0,
+ kB = 1,
+ kC = 2,
+ kD = 3,
+};
+
+struct Type
+{
+public:
+ uint8_t a = static_cast<uint8_t>(0);
+ bool b = static_cast<bool>(0);
+ Structs::SimpleStruct::Type c;
+ Optional<Globals::Structs::TestGlobalStruct::Type> d;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace NestedStruct
+namespace NestedStructList {
+enum class Fields : uint8_t
+{
+ kA = 0,
+ kB = 1,
+ kC = 2,
+ kD = 3,
+ kE = 4,
+ kF = 5,
+ kG = 6,
+};
+
+struct Type
+{
+public:
+ uint8_t a = static_cast<uint8_t>(0);
+ bool b = static_cast<bool>(0);
+ Structs::SimpleStruct::Type c;
+ DataModel::List<const Structs::SimpleStruct::Type> d;
+ DataModel::List<const uint32_t> e;
+ DataModel::List<const chip::ByteSpan> f;
+ DataModel::List<const uint8_t> g;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ uint8_t a = static_cast<uint8_t>(0);
+ bool b = static_cast<bool>(0);
+ Structs::SimpleStruct::DecodableType c;
+ DataModel::DecodableList<Structs::SimpleStruct::DecodableType> d;
+ DataModel::DecodableList<uint32_t> e;
+ DataModel::DecodableList<chip::ByteSpan> f;
+ DataModel::DecodableList<uint8_t> g;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace NestedStructList
+namespace DoubleNestedStructList {
+enum class Fields : uint8_t
+{
+ kA = 0,
+};
+
+struct Type
+{
+public:
+ DataModel::List<const Structs::NestedStructList::Type> a;
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ DataModel::DecodableList<Structs::NestedStructList::DecodableType> a;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+};
+
+} // namespace DoubleNestedStructList
+namespace TestListStructOctet {
+enum class Fields : uint8_t
+{
+ kMember1 = 0,
+ kMember2 = 1,
+};
+
+struct Type
+{
+public:
+ uint64_t member1 = static_cast<uint64_t>(0);
+ chip::ByteSpan member2;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+
+ static constexpr bool kIsFabricScoped = false;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+using DecodableType = Type;
+
+} // namespace TestListStructOctet
+} // namespace Structs
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Test {
+struct Type;
+struct DecodableType;
+} // namespace Test
+
+namespace TestSpecificResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestSpecificResponse
+
+namespace TestNotHandled {
+struct Type;
+struct DecodableType;
+} // namespace TestNotHandled
+
+namespace TestAddArgumentsResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestAddArgumentsResponse
+
+namespace TestSpecific {
+struct Type;
+struct DecodableType;
+} // namespace TestSpecific
+
+namespace TestSimpleArgumentResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestSimpleArgumentResponse
+
+namespace TestUnknownCommand {
+struct Type;
+struct DecodableType;
+} // namespace TestUnknownCommand
+
+namespace TestStructArrayArgumentResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestStructArrayArgumentResponse
+
+namespace TestAddArguments {
+struct Type;
+struct DecodableType;
+} // namespace TestAddArguments
+
+namespace TestListInt8UReverseResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestListInt8UReverseResponse
+
+namespace TestSimpleArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestSimpleArgumentRequest
+
+namespace TestEnumsResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestEnumsResponse
+
+namespace TestStructArrayArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestStructArrayArgumentRequest
+
+namespace TestNullableOptionalResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestNullableOptionalResponse
+
+namespace TestStructArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestStructArgumentRequest
+
+namespace TestComplexNullableOptionalResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestComplexNullableOptionalResponse
+
+namespace TestNestedStructArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestNestedStructArgumentRequest
+
+namespace BooleanResponse {
+struct Type;
+struct DecodableType;
+} // namespace BooleanResponse
+
+namespace TestListStructArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestListStructArgumentRequest
+
+namespace SimpleStructResponse {
+struct Type;
+struct DecodableType;
+} // namespace SimpleStructResponse
+
+namespace TestListInt8UArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestListInt8UArgumentRequest
+
+namespace TestEmitTestEventResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestEmitTestEventResponse
+
+namespace TestNestedStructListArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestNestedStructListArgumentRequest
+
+namespace TestEmitTestFabricScopedEventResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestEmitTestFabricScopedEventResponse
+
+namespace TestListNestedStructListArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestListNestedStructListArgumentRequest
+
+namespace TestBatchHelperResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestBatchHelperResponse
+
+namespace TestListInt8UReverseRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestListInt8UReverseRequest
+
+namespace StringEchoResponse {
+struct Type;
+struct DecodableType;
+} // namespace StringEchoResponse
+
+namespace TestEnumsRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestEnumsRequest
+
+namespace GlobalEchoResponse {
+struct Type;
+struct DecodableType;
+} // namespace GlobalEchoResponse
+
+namespace TestNullableOptionalRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestNullableOptionalRequest
+
+namespace TestComplexNullableOptionalRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestComplexNullableOptionalRequest
+
+namespace SimpleStructEchoRequest {
+struct Type;
+struct DecodableType;
+} // namespace SimpleStructEchoRequest
+
+namespace TimedInvokeRequest {
+struct Type;
+struct DecodableType;
+} // namespace TimedInvokeRequest
+
+namespace TestSimpleOptionalArgumentRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestSimpleOptionalArgumentRequest
+
+namespace TestEmitTestEventRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestEmitTestEventRequest
+
+namespace TestEmitTestFabricScopedEventRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestEmitTestFabricScopedEventRequest
+
+namespace TestBatchHelperRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestBatchHelperRequest
+
+namespace TestSecondBatchHelperRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestSecondBatchHelperRequest
+
+namespace StringEchoRequest {
+struct Type;
+struct DecodableType;
+} // namespace StringEchoRequest
+
+namespace GlobalEchoRequest {
+struct Type;
+struct DecodableType;
+} // namespace GlobalEchoRequest
+
+namespace TestDifferentVendorMeiRequest {
+struct Type;
+struct DecodableType;
+} // namespace TestDifferentVendorMeiRequest
+
+namespace TestDifferentVendorMeiResponse {
+struct Type;
+struct DecodableType;
+} // namespace TestDifferentVendorMeiResponse
+
+} // namespace Commands
+
+namespace Commands {
+namespace Test {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Test::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Test::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Test
+namespace TestSpecificResponse {
+enum class Fields : uint8_t
+{
+ kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestSpecificResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestSpecificResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSpecificResponse
+namespace TestNotHandled {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestNotHandled::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestNotHandled::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestNotHandled
+namespace TestAddArgumentsResponse {
+enum class Fields : uint8_t
+{
+ kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestAddArgumentsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestAddArgumentsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestAddArgumentsResponse
+namespace TestSpecific {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestSpecific::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestSpecificResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestSpecific::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSpecific
+namespace TestSimpleArgumentResponse {
+enum class Fields : uint8_t
+{
+ kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestSimpleArgumentResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool returnValue = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestSimpleArgumentResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool returnValue = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSimpleArgumentResponse
+namespace TestUnknownCommand {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestUnknownCommand::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestUnknownCommand::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestUnknownCommand
+namespace TestStructArrayArgumentResponse {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+ kArg3 = 2,
+ kArg4 = 3,
+ kArg5 = 4,
+ kArg6 = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestStructArrayArgumentResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const Structs::NestedStructList::Type> arg1;
+ DataModel::List<const Structs::SimpleStruct::Type> arg2;
+ DataModel::List<const SimpleEnum> arg3;
+ DataModel::List<const bool> arg4;
+ SimpleEnum arg5 = static_cast<SimpleEnum>(0);
+ bool arg6 = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestStructArrayArgumentResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
+ DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
+ DataModel::DecodableList<SimpleEnum> arg3;
+ DataModel::DecodableList<bool> arg4;
+ SimpleEnum arg5 = static_cast<SimpleEnum>(0);
+ bool arg6 = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestStructArrayArgumentResponse
+namespace TestAddArguments {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestAddArguments::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint8_t arg2 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestAddArgumentsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestAddArguments::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint8_t arg2 = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestAddArguments
+namespace TestListInt8UReverseResponse {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestListInt8UReverseResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const uint8_t> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestListInt8UReverseResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<uint8_t> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestListInt8UReverseResponse
+namespace TestSimpleArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestSimpleArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool arg1 = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestSimpleArgumentResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestSimpleArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool arg1 = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSimpleArgumentRequest
+namespace TestEnumsResponse {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEnumsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::VendorId arg1 = static_cast<chip::VendorId>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEnumsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::VendorId arg1 = static_cast<chip::VendorId>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEnumsResponse
+namespace TestStructArrayArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+ kArg3 = 2,
+ kArg4 = 3,
+ kArg5 = 4,
+ kArg6 = 5,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestStructArrayArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const Structs::NestedStructList::Type> arg1;
+ DataModel::List<const Structs::SimpleStruct::Type> arg2;
+ DataModel::List<const SimpleEnum> arg3;
+ DataModel::List<const bool> arg4;
+ SimpleEnum arg5 = static_cast<SimpleEnum>(0);
+ bool arg6 = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestStructArrayArgumentResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestStructArrayArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
+ DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
+ DataModel::DecodableList<SimpleEnum> arg3;
+ DataModel::DecodableList<bool> arg4;
+ SimpleEnum arg5 = static_cast<SimpleEnum>(0);
+ bool arg6 = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestStructArrayArgumentRequest
+namespace TestNullableOptionalResponse {
+enum class Fields : uint8_t
+{
+ kWasPresent = 0,
+ kWasNull = 1,
+ kValue = 2,
+ kOriginalValue = 3,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestNullableOptionalResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool wasPresent = static_cast<bool>(0);
+ Optional<bool> wasNull;
+ Optional<uint8_t> value;
+ Optional<DataModel::Nullable<uint8_t>> originalValue;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestNullableOptionalResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool wasPresent = static_cast<bool>(0);
+ Optional<bool> wasNull;
+ Optional<uint8_t> value;
+ Optional<DataModel::Nullable<uint8_t>> originalValue;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestNullableOptionalResponse
+namespace TestStructArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestStructArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::SimpleStruct::Type arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestStructArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::SimpleStruct::DecodableType arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestStructArgumentRequest
+namespace TestComplexNullableOptionalResponse {
+enum class Fields : uint8_t
+{
+ kNullableIntWasNull = 0,
+ kNullableIntValue = 1,
+ kOptionalIntWasPresent = 2,
+ kOptionalIntValue = 3,
+ kNullableOptionalIntWasPresent = 4,
+ kNullableOptionalIntWasNull = 5,
+ kNullableOptionalIntValue = 6,
+ kNullableStringWasNull = 7,
+ kNullableStringValue = 8,
+ kOptionalStringWasPresent = 9,
+ kOptionalStringValue = 10,
+ kNullableOptionalStringWasPresent = 11,
+ kNullableOptionalStringWasNull = 12,
+ kNullableOptionalStringValue = 13,
+ kNullableStructWasNull = 14,
+ kNullableStructValue = 15,
+ kOptionalStructWasPresent = 16,
+ kOptionalStructValue = 17,
+ kNullableOptionalStructWasPresent = 18,
+ kNullableOptionalStructWasNull = 19,
+ kNullableOptionalStructValue = 20,
+ kNullableListWasNull = 21,
+ kNullableListValue = 22,
+ kOptionalListWasPresent = 23,
+ kOptionalListValue = 24,
+ kNullableOptionalListWasPresent = 25,
+ kNullableOptionalListWasNull = 26,
+ kNullableOptionalListValue = 27,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestComplexNullableOptionalResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool nullableIntWasNull = static_cast<bool>(0);
+ Optional<uint16_t> nullableIntValue;
+ bool optionalIntWasPresent = static_cast<bool>(0);
+ Optional<uint16_t> optionalIntValue;
+ bool nullableOptionalIntWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalIntWasNull;
+ Optional<uint16_t> nullableOptionalIntValue;
+ bool nullableStringWasNull = static_cast<bool>(0);
+ Optional<chip::CharSpan> nullableStringValue;
+ bool optionalStringWasPresent = static_cast<bool>(0);
+ Optional<chip::CharSpan> optionalStringValue;
+ bool nullableOptionalStringWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalStringWasNull;
+ Optional<chip::CharSpan> nullableOptionalStringValue;
+ bool nullableStructWasNull = static_cast<bool>(0);
+ Optional<Structs::SimpleStruct::Type> nullableStructValue;
+ bool optionalStructWasPresent = static_cast<bool>(0);
+ Optional<Structs::SimpleStruct::Type> optionalStructValue;
+ bool nullableOptionalStructWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalStructWasNull;
+ Optional<Structs::SimpleStruct::Type> nullableOptionalStructValue;
+ bool nullableListWasNull = static_cast<bool>(0);
+ Optional<DataModel::List<const SimpleEnum>> nullableListValue;
+ bool optionalListWasPresent = static_cast<bool>(0);
+ Optional<DataModel::List<const SimpleEnum>> optionalListValue;
+ bool nullableOptionalListWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalListWasNull;
+ Optional<DataModel::List<const SimpleEnum>> nullableOptionalListValue;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestComplexNullableOptionalResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool nullableIntWasNull = static_cast<bool>(0);
+ Optional<uint16_t> nullableIntValue;
+ bool optionalIntWasPresent = static_cast<bool>(0);
+ Optional<uint16_t> optionalIntValue;
+ bool nullableOptionalIntWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalIntWasNull;
+ Optional<uint16_t> nullableOptionalIntValue;
+ bool nullableStringWasNull = static_cast<bool>(0);
+ Optional<chip::CharSpan> nullableStringValue;
+ bool optionalStringWasPresent = static_cast<bool>(0);
+ Optional<chip::CharSpan> optionalStringValue;
+ bool nullableOptionalStringWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalStringWasNull;
+ Optional<chip::CharSpan> nullableOptionalStringValue;
+ bool nullableStructWasNull = static_cast<bool>(0);
+ Optional<Structs::SimpleStruct::DecodableType> nullableStructValue;
+ bool optionalStructWasPresent = static_cast<bool>(0);
+ Optional<Structs::SimpleStruct::DecodableType> optionalStructValue;
+ bool nullableOptionalStructWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalStructWasNull;
+ Optional<Structs::SimpleStruct::DecodableType> nullableOptionalStructValue;
+ bool nullableListWasNull = static_cast<bool>(0);
+ Optional<DataModel::DecodableList<SimpleEnum>> nullableListValue;
+ bool optionalListWasPresent = static_cast<bool>(0);
+ Optional<DataModel::DecodableList<SimpleEnum>> optionalListValue;
+ bool nullableOptionalListWasPresent = static_cast<bool>(0);
+ Optional<bool> nullableOptionalListWasNull;
+ Optional<DataModel::DecodableList<SimpleEnum>> nullableOptionalListValue;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestComplexNullableOptionalResponse
+namespace TestNestedStructArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestNestedStructArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::NestedStruct::Type arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestNestedStructArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::NestedStruct::DecodableType arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestNestedStructArgumentRequest
+namespace BooleanResponse {
+enum class Fields : uint8_t
+{
+ kValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::BooleanResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool value = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::BooleanResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ bool value = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace BooleanResponse
+namespace TestListStructArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestListStructArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const Structs::SimpleStruct::Type> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestListStructArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestListStructArgumentRequest
+namespace SimpleStructResponse {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SimpleStructResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::SimpleStruct::Type arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SimpleStructResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::SimpleStruct::DecodableType arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SimpleStructResponse
+namespace TestListInt8UArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestListInt8UArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const uint8_t> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestListInt8UArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<uint8_t> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestListInt8UArgumentRequest
+namespace TestEmitTestEventResponse {
+enum class Fields : uint8_t
+{
+ kValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestEventResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint64_t value = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestEventResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint64_t value = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEmitTestEventResponse
+namespace TestNestedStructListArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestNestedStructListArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::NestedStructList::Type arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestNestedStructListArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::NestedStructList::DecodableType arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestNestedStructListArgumentRequest
+namespace TestEmitTestFabricScopedEventResponse {
+enum class Fields : uint8_t
+{
+ kValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestFabricScopedEventResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint64_t value = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestFabricScopedEventResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint64_t value = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEmitTestFabricScopedEventResponse
+namespace TestListNestedStructListArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestListNestedStructListArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const Structs::NestedStructList::Type> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestListNestedStructListArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestListNestedStructListArgumentRequest
+namespace TestBatchHelperResponse {
+enum class Fields : uint8_t
+{
+ kBuffer = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestBatchHelperResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::ByteSpan buffer;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestBatchHelperResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::ByteSpan buffer;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestBatchHelperResponse
+namespace TestListInt8UReverseRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestListInt8UReverseRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::List<const uint8_t> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestListInt8UReverseResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestListInt8UReverseRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::DecodableList<uint8_t> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestListInt8UReverseRequest
+namespace StringEchoResponse {
+enum class Fields : uint8_t
+{
+ kPayload = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StringEchoResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::ByteSpan payload;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StringEchoResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::ByteSpan payload;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StringEchoResponse
+namespace TestEnumsRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEnumsRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::VendorId arg1 = static_cast<chip::VendorId>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestEnumsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEnumsRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::VendorId arg1 = static_cast<chip::VendorId>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEnumsRequest
+namespace GlobalEchoResponse {
+enum class Fields : uint8_t
+{
+ kField1 = 0,
+ kField2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GlobalEchoResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Globals::Structs::TestGlobalStruct::Type field1;
+ Globals::TestGlobalEnum field2 = static_cast<Globals::TestGlobalEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GlobalEchoResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Globals::Structs::TestGlobalStruct::DecodableType field1;
+ Globals::TestGlobalEnum field2 = static_cast<Globals::TestGlobalEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GlobalEchoResponse
+namespace TestNullableOptionalRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestNullableOptionalRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Optional<DataModel::Nullable<uint8_t>> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestNullableOptionalResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestNullableOptionalRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Optional<DataModel::Nullable<uint8_t>> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestNullableOptionalRequest
+namespace TestComplexNullableOptionalRequest {
+enum class Fields : uint8_t
+{
+ kNullableInt = 0,
+ kOptionalInt = 1,
+ kNullableOptionalInt = 2,
+ kNullableString = 3,
+ kOptionalString = 4,
+ kNullableOptionalString = 5,
+ kNullableStruct = 6,
+ kOptionalStruct = 7,
+ kNullableOptionalStruct = 8,
+ kNullableList = 9,
+ kOptionalList = 10,
+ kNullableOptionalList = 11,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestComplexNullableOptionalRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::Nullable<uint16_t> nullableInt;
+ Optional<uint16_t> optionalInt;
+ Optional<DataModel::Nullable<uint16_t>> nullableOptionalInt;
+ DataModel::Nullable<chip::CharSpan> nullableString;
+ Optional<chip::CharSpan> optionalString;
+ Optional<DataModel::Nullable<chip::CharSpan>> nullableOptionalString;
+ DataModel::Nullable<Structs::SimpleStruct::Type> nullableStruct;
+ Optional<Structs::SimpleStruct::Type> optionalStruct;
+ Optional<DataModel::Nullable<Structs::SimpleStruct::Type>> nullableOptionalStruct;
+ DataModel::Nullable<DataModel::List<const SimpleEnum>> nullableList;
+ Optional<DataModel::List<const SimpleEnum>> optionalList;
+ Optional<DataModel::Nullable<DataModel::List<const SimpleEnum>>> nullableOptionalList;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestComplexNullableOptionalResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestComplexNullableOptionalRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ DataModel::Nullable<uint16_t> nullableInt;
+ Optional<uint16_t> optionalInt;
+ Optional<DataModel::Nullable<uint16_t>> nullableOptionalInt;
+ DataModel::Nullable<chip::CharSpan> nullableString;
+ Optional<chip::CharSpan> optionalString;
+ Optional<DataModel::Nullable<chip::CharSpan>> nullableOptionalString;
+ DataModel::Nullable<Structs::SimpleStruct::DecodableType> nullableStruct;
+ Optional<Structs::SimpleStruct::DecodableType> optionalStruct;
+ Optional<DataModel::Nullable<Structs::SimpleStruct::DecodableType>> nullableOptionalStruct;
+ DataModel::Nullable<DataModel::DecodableList<SimpleEnum>> nullableList;
+ Optional<DataModel::DecodableList<SimpleEnum>> optionalList;
+ Optional<DataModel::Nullable<DataModel::DecodableList<SimpleEnum>>> nullableOptionalList;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestComplexNullableOptionalRequest
+namespace SimpleStructEchoRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::SimpleStructEchoRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::SimpleStruct::Type arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::SimpleStructResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::SimpleStructEchoRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Structs::SimpleStruct::DecodableType arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace SimpleStructEchoRequest
+namespace TimedInvokeRequest {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TimedInvokeRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return true; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TimedInvokeRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TimedInvokeRequest
+namespace TestSimpleOptionalArgumentRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestSimpleOptionalArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Optional<bool> arg1;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestSimpleOptionalArgumentRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Optional<bool> arg1;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSimpleOptionalArgumentRequest
+namespace TestEmitTestEventRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+ kArg3 = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+ bool arg3 = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestEmitTestEventResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+ bool arg3 = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEmitTestEventRequest
+namespace TestEmitTestFabricScopedEventRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestFabricScopedEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestEmitTestFabricScopedEventResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestEmitTestFabricScopedEventRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestEmitTestFabricScopedEventRequest
+namespace TestBatchHelperRequest {
+enum class Fields : uint8_t
+{
+ kSleepBeforeResponseTimeMs = 0,
+ kSizeOfResponseBuffer = 1,
+ kFillCharacter = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestBatchHelperRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
+ uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
+ uint8_t fillCharacter = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestBatchHelperResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestBatchHelperRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
+ uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
+ uint8_t fillCharacter = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestBatchHelperRequest
+namespace TestSecondBatchHelperRequest {
+enum class Fields : uint8_t
+{
+ kSleepBeforeResponseTimeMs = 0,
+ kSizeOfResponseBuffer = 1,
+ kFillCharacter = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestSecondBatchHelperRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
+ uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
+ uint8_t fillCharacter = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestBatchHelperResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestSecondBatchHelperRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
+ uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
+ uint8_t fillCharacter = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestSecondBatchHelperRequest
+namespace StringEchoRequest {
+enum class Fields : uint8_t
+{
+ kPayload = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::StringEchoRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::ByteSpan payload;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::StringEchoResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::StringEchoRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::ByteSpan payload;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace StringEchoRequest
+namespace GlobalEchoRequest {
+enum class Fields : uint8_t
+{
+ kField1 = 0,
+ kField2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::GlobalEchoRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Globals::Structs::TestGlobalStruct::Type field1;
+ Globals::TestGlobalEnum field2 = static_cast<Globals::TestGlobalEnum>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::GlobalEchoResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::GlobalEchoRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ Globals::Structs::TestGlobalStruct::DecodableType field1;
+ Globals::TestGlobalEnum field2 = static_cast<Globals::TestGlobalEnum>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace GlobalEchoRequest
+namespace TestDifferentVendorMeiRequest {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestDifferentVendorMeiRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::UnitTesting::Commands::TestDifferentVendorMeiResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestDifferentVendorMeiRequest::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestDifferentVendorMeiRequest
+namespace TestDifferentVendorMeiResponse {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kEventNumber = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::TestDifferentVendorMeiResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint64_t eventNumber = static_cast<uint64_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::TestDifferentVendorMeiResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint64_t eventNumber = static_cast<uint64_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace TestDifferentVendorMeiResponse
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Boolean {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Boolean::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Boolean
+namespace Bitmap8 {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap8::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Bitmap8
+namespace Bitmap16 {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap16::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Bitmap16
+namespace Bitmap32 {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap32::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Bitmap32
+namespace Bitmap64 {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Bitmap64::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Bitmap64
+namespace Int8u {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int8u
+namespace Int16u {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int16u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int16u
+namespace Int24u {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int24u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int24u
+namespace Int32u {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int32u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int32u
+namespace Int40u {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int40u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int40u
+namespace Int48u {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int48u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int48u
+namespace Int56u {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int56u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int56u
+namespace Int64u {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int64u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int64u
+namespace Int8s {
+struct TypeInfo
+{
+ using Type = int8_t;
+ using DecodableType = int8_t;
+ using DecodableArgType = int8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int8s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int8s
+namespace Int16s {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int16s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int16s
+namespace Int24s {
+struct TypeInfo
+{
+ using Type = int32_t;
+ using DecodableType = int32_t;
+ using DecodableArgType = int32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int24s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int24s
+namespace Int32s {
+struct TypeInfo
+{
+ using Type = int32_t;
+ using DecodableType = int32_t;
+ using DecodableArgType = int32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int32s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int32s
+namespace Int40s {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int40s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int40s
+namespace Int48s {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int48s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int48s
+namespace Int56s {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int56s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int56s
+namespace Int64s {
+struct TypeInfo
+{
+ using Type = int64_t;
+ using DecodableType = int64_t;
+ using DecodableArgType = int64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Int64s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Int64s
+namespace Enum8 {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Enum8::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Enum8
+namespace Enum16 {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Enum16::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Enum16
+namespace FloatSingle {
+struct TypeInfo
+{
+ using Type = float;
+ using DecodableType = float;
+ using DecodableArgType = float;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FloatSingle::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FloatSingle
+namespace FloatDouble {
+struct TypeInfo
+{
+ using Type = double;
+ using DecodableType = double;
+ using DecodableArgType = double;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FloatDouble::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FloatDouble
+namespace OctetString {
+struct TypeInfo
+{
+ using Type = chip::ByteSpan;
+ using DecodableType = chip::ByteSpan;
+ using DecodableArgType = chip::ByteSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::OctetString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 10; }
+};
+} // namespace OctetString
+namespace ListInt8u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const uint8_t>;
+ using DecodableType = chip::app::DataModel::DecodableList<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ListInt8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ListInt8u
+namespace ListOctetString {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ListOctetString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ListOctetString
+namespace ListStructOctetString {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ListStructOctetString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ListStructOctetString
+namespace LongOctetString {
+struct TypeInfo
+{
+ using Type = chip::ByteSpan;
+ using DecodableType = chip::ByteSpan;
+ using DecodableArgType = chip::ByteSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LongOctetString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 1000; }
+};
+} // namespace LongOctetString
+namespace CharString {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::CharString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 10; }
+};
+} // namespace CharString
+namespace LongCharString {
+struct TypeInfo
+{
+ using Type = chip::CharSpan;
+ using DecodableType = chip::CharSpan;
+ using DecodableArgType = chip::CharSpan;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::LongCharString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 1000; }
+};
+} // namespace LongCharString
+namespace EpochUs {
+struct TypeInfo
+{
+ using Type = uint64_t;
+ using DecodableType = uint64_t;
+ using DecodableArgType = uint64_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EpochUs::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EpochUs
+namespace EpochS {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EpochS::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EpochS
+namespace VendorId {
+struct TypeInfo
+{
+ using Type = chip::VendorId;
+ using DecodableType = chip::VendorId;
+ using DecodableArgType = chip::VendorId;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::VendorId::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace VendorId
+namespace ListNullablesAndOptionalsStruct {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<
+ chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ListNullablesAndOptionalsStruct::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ListNullablesAndOptionalsStruct
+namespace EnumAttr {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::UnitTesting::SimpleEnum;
+ using DecodableType = chip::app::Clusters::UnitTesting::SimpleEnum;
+ using DecodableArgType = chip::app::Clusters::UnitTesting::SimpleEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::EnumAttr::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace EnumAttr
+namespace StructAttr {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type;
+ using DecodableType = chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::StructAttr::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace StructAttr
+namespace RangeRestrictedInt8u {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RangeRestrictedInt8u
+namespace RangeRestrictedInt8s {
+struct TypeInfo
+{
+ using Type = int8_t;
+ using DecodableType = int8_t;
+ using DecodableArgType = int8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt8s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RangeRestrictedInt8s
+namespace RangeRestrictedInt16u {
+struct TypeInfo
+{
+ using Type = uint16_t;
+ using DecodableType = uint16_t;
+ using DecodableArgType = uint16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt16u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RangeRestrictedInt16u
+namespace RangeRestrictedInt16s {
+struct TypeInfo
+{
+ using Type = int16_t;
+ using DecodableType = int16_t;
+ using DecodableArgType = int16_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt16s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace RangeRestrictedInt16s
+namespace ListLongOctetString {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ListLongOctetString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ListLongOctetString
+namespace ListFabricScoped {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::Type>;
+ using DecodableType =
+ chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::DecodableList<chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ListFabricScoped::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ListFabricScoped
+namespace TimedWriteBoolean {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::TimedWriteBoolean::Id; }
+ static constexpr bool MustUseTimedWrite() { return true; }
+};
+} // namespace TimedWriteBoolean
+namespace GeneralErrorBoolean {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::GeneralErrorBoolean::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GeneralErrorBoolean
+namespace ClusterErrorBoolean {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ClusterErrorBoolean::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ClusterErrorBoolean
+namespace GlobalEnum {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Globals::TestGlobalEnum;
+ using DecodableType = chip::app::Clusters::Globals::TestGlobalEnum;
+ using DecodableArgType = chip::app::Clusters::Globals::TestGlobalEnum;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::GlobalEnum::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GlobalEnum
+namespace GlobalStruct {
+struct TypeInfo
+{
+ using Type = chip::app::Clusters::Globals::Structs::TestGlobalStruct::Type;
+ using DecodableType = chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType;
+ using DecodableArgType = const chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::GlobalStruct::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace GlobalStruct
+namespace Unsupported {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Unsupported::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Unsupported
+namespace ReadFailureCode {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::ReadFailureCode::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace ReadFailureCode
+namespace FailureInt32U {
+struct TypeInfo
+{
+ using Type = uint32_t;
+ using DecodableType = uint32_t;
+ using DecodableArgType = uint32_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FailureInt32U::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FailureInt32U
+namespace NullableBoolean {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<bool>;
+ using DecodableType = chip::app::DataModel::Nullable<bool>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<bool> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableBoolean::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableBoolean
+namespace NullableBitmap8 {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableBitmap8::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableBitmap8
+namespace NullableBitmap16 {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableBitmap16::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableBitmap16
+namespace NullableBitmap32 {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableBitmap32::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableBitmap32
+namespace NullableBitmap64 {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableBitmap64::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableBitmap64
+namespace NullableInt8u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt8u
+namespace NullableInt16u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt16u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt16u
+namespace NullableInt24u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt24u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt24u
+namespace NullableInt32u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt32u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt32u
+namespace NullableInt40u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt40u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt40u
+namespace NullableInt48u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt48u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt48u
+namespace NullableInt56u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt56u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt56u
+namespace NullableInt64u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt64u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt64u
+namespace NullableInt8s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt8s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt8s
+namespace NullableInt16s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt16s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt16s
+namespace NullableInt24s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt24s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt24s
+namespace NullableInt32s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int32_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int32_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int32_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt32s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt32s
+namespace NullableInt40s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt40s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt40s
+namespace NullableInt48s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt48s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt48s
+namespace NullableInt56s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt56s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt56s
+namespace NullableInt64s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int64_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int64_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt64s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableInt64s
+namespace NullableEnum8 {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableEnum8::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableEnum8
+namespace NullableEnum16 {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableEnum16::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableEnum16
+namespace NullableFloatSingle {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<float>;
+ using DecodableType = chip::app::DataModel::Nullable<float>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<float> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableFloatSingle::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableFloatSingle
+namespace NullableFloatDouble {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<double>;
+ using DecodableType = chip::app::DataModel::Nullable<double>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<double> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableFloatDouble::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableFloatDouble
+namespace NullableOctetString {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableOctetString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 10; }
+};
+} // namespace NullableOctetString
+namespace NullableCharString {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::CharSpan> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableCharString::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+ static constexpr size_t MaxLength() { return 10; }
+};
+} // namespace NullableCharString
+namespace NullableEnumAttr {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableEnumAttr::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableEnumAttr
+namespace NullableStruct {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableStruct::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableStruct
+namespace NullableRangeRestrictedInt8u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableRangeRestrictedInt8u
+namespace NullableRangeRestrictedInt8s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int8_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int8_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int8_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt8s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableRangeRestrictedInt8s
+namespace NullableRangeRestrictedInt16u {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt16u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableRangeRestrictedInt16u
+namespace NullableRangeRestrictedInt16s {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableType = chip::app::DataModel::Nullable<int16_t>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<int16_t> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt16s::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableRangeRestrictedInt16s
+namespace WriteOnlyInt8u {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::WriteOnlyInt8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace WriteOnlyInt8u
+namespace NullableGlobalEnum {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum>;
+ using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::Globals::TestGlobalEnum> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableGlobalEnum::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableGlobalEnum
+namespace NullableGlobalStruct {
+struct TypeInfo
+{
+ using Type = chip::app::DataModel::Nullable<chip::app::Clusters::Globals::Structs::TestGlobalStruct::Type>;
+ using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType>;
+ using DecodableArgType =
+ const chip::app::DataModel::Nullable<chip::app::Clusters::Globals::Structs::TestGlobalStruct::DecodableType> &;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::NullableGlobalStruct::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace NullableGlobalStruct
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+};
+} // namespace ClusterRevision
+namespace MeiInt8u {
+struct TypeInfo
+{
+ using Type = uint8_t;
+ using DecodableType = uint8_t;
+ using DecodableArgType = uint8_t;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::MeiInt8u::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace MeiInt8u
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Boolean::TypeInfo::DecodableType boolean = static_cast<bool>(0);
+ Attributes::Bitmap8::TypeInfo::DecodableType bitmap8 =
+ static_cast<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>(0);
+ Attributes::Bitmap16::TypeInfo::DecodableType bitmap16 =
+ static_cast<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>(0);
+ Attributes::Bitmap32::TypeInfo::DecodableType bitmap32 =
+ static_cast<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>(0);
+ Attributes::Bitmap64::TypeInfo::DecodableType bitmap64 =
+ static_cast<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>(0);
+ Attributes::Int8u::TypeInfo::DecodableType int8u = static_cast<uint8_t>(0);
+ Attributes::Int16u::TypeInfo::DecodableType int16u = static_cast<uint16_t>(0);
+ Attributes::Int24u::TypeInfo::DecodableType int24u = static_cast<uint32_t>(0);
+ Attributes::Int32u::TypeInfo::DecodableType int32u = static_cast<uint32_t>(0);
+ Attributes::Int40u::TypeInfo::DecodableType int40u = static_cast<uint64_t>(0);
+ Attributes::Int48u::TypeInfo::DecodableType int48u = static_cast<uint64_t>(0);
+ Attributes::Int56u::TypeInfo::DecodableType int56u = static_cast<uint64_t>(0);
+ Attributes::Int64u::TypeInfo::DecodableType int64u = static_cast<uint64_t>(0);
+ Attributes::Int8s::TypeInfo::DecodableType int8s = static_cast<int8_t>(0);
+ Attributes::Int16s::TypeInfo::DecodableType int16s = static_cast<int16_t>(0);
+ Attributes::Int24s::TypeInfo::DecodableType int24s = static_cast<int32_t>(0);
+ Attributes::Int32s::TypeInfo::DecodableType int32s = static_cast<int32_t>(0);
+ Attributes::Int40s::TypeInfo::DecodableType int40s = static_cast<int64_t>(0);
+ Attributes::Int48s::TypeInfo::DecodableType int48s = static_cast<int64_t>(0);
+ Attributes::Int56s::TypeInfo::DecodableType int56s = static_cast<int64_t>(0);
+ Attributes::Int64s::TypeInfo::DecodableType int64s = static_cast<int64_t>(0);
+ Attributes::Enum8::TypeInfo::DecodableType enum8 = static_cast<uint8_t>(0);
+ Attributes::Enum16::TypeInfo::DecodableType enum16 = static_cast<uint16_t>(0);
+ Attributes::FloatSingle::TypeInfo::DecodableType floatSingle = static_cast<float>(0);
+ Attributes::FloatDouble::TypeInfo::DecodableType floatDouble = static_cast<double>(0);
+ Attributes::OctetString::TypeInfo::DecodableType octetString;
+ Attributes::ListInt8u::TypeInfo::DecodableType listInt8u;
+ Attributes::ListOctetString::TypeInfo::DecodableType listOctetString;
+ Attributes::ListStructOctetString::TypeInfo::DecodableType listStructOctetString;
+ Attributes::LongOctetString::TypeInfo::DecodableType longOctetString;
+ Attributes::CharString::TypeInfo::DecodableType charString;
+ Attributes::LongCharString::TypeInfo::DecodableType longCharString;
+ Attributes::EpochUs::TypeInfo::DecodableType epochUs = static_cast<uint64_t>(0);
+ Attributes::EpochS::TypeInfo::DecodableType epochS = static_cast<uint32_t>(0);
+ Attributes::VendorId::TypeInfo::DecodableType vendorId = static_cast<chip::VendorId>(0);
+ Attributes::ListNullablesAndOptionalsStruct::TypeInfo::DecodableType listNullablesAndOptionalsStruct;
+ Attributes::EnumAttr::TypeInfo::DecodableType enumAttr = static_cast<chip::app::Clusters::UnitTesting::SimpleEnum>(0);
+ Attributes::StructAttr::TypeInfo::DecodableType structAttr;
+ Attributes::RangeRestrictedInt8u::TypeInfo::DecodableType rangeRestrictedInt8u = static_cast<uint8_t>(0);
+ Attributes::RangeRestrictedInt8s::TypeInfo::DecodableType rangeRestrictedInt8s = static_cast<int8_t>(0);
+ Attributes::RangeRestrictedInt16u::TypeInfo::DecodableType rangeRestrictedInt16u = static_cast<uint16_t>(0);
+ Attributes::RangeRestrictedInt16s::TypeInfo::DecodableType rangeRestrictedInt16s = static_cast<int16_t>(0);
+ Attributes::ListLongOctetString::TypeInfo::DecodableType listLongOctetString;
+ Attributes::ListFabricScoped::TypeInfo::DecodableType listFabricScoped;
+ Attributes::TimedWriteBoolean::TypeInfo::DecodableType timedWriteBoolean = static_cast<bool>(0);
+ Attributes::GeneralErrorBoolean::TypeInfo::DecodableType generalErrorBoolean = static_cast<bool>(0);
+ Attributes::ClusterErrorBoolean::TypeInfo::DecodableType clusterErrorBoolean = static_cast<bool>(0);
+ Attributes::GlobalEnum::TypeInfo::DecodableType globalEnum = static_cast<chip::app::Clusters::Globals::TestGlobalEnum>(0);
+ Attributes::GlobalStruct::TypeInfo::DecodableType globalStruct;
+ Attributes::Unsupported::TypeInfo::DecodableType unsupported = static_cast<bool>(0);
+ Attributes::ReadFailureCode::TypeInfo::DecodableType readFailureCode = static_cast<uint8_t>(0);
+ Attributes::FailureInt32U::TypeInfo::DecodableType failureInt32U = static_cast<uint32_t>(0);
+ Attributes::NullableBoolean::TypeInfo::DecodableType nullableBoolean;
+ Attributes::NullableBitmap8::TypeInfo::DecodableType nullableBitmap8;
+ Attributes::NullableBitmap16::TypeInfo::DecodableType nullableBitmap16;
+ Attributes::NullableBitmap32::TypeInfo::DecodableType nullableBitmap32;
+ Attributes::NullableBitmap64::TypeInfo::DecodableType nullableBitmap64;
+ Attributes::NullableInt8u::TypeInfo::DecodableType nullableInt8u;
+ Attributes::NullableInt16u::TypeInfo::DecodableType nullableInt16u;
+ Attributes::NullableInt24u::TypeInfo::DecodableType nullableInt24u;
+ Attributes::NullableInt32u::TypeInfo::DecodableType nullableInt32u;
+ Attributes::NullableInt40u::TypeInfo::DecodableType nullableInt40u;
+ Attributes::NullableInt48u::TypeInfo::DecodableType nullableInt48u;
+ Attributes::NullableInt56u::TypeInfo::DecodableType nullableInt56u;
+ Attributes::NullableInt64u::TypeInfo::DecodableType nullableInt64u;
+ Attributes::NullableInt8s::TypeInfo::DecodableType nullableInt8s;
+ Attributes::NullableInt16s::TypeInfo::DecodableType nullableInt16s;
+ Attributes::NullableInt24s::TypeInfo::DecodableType nullableInt24s;
+ Attributes::NullableInt32s::TypeInfo::DecodableType nullableInt32s;
+ Attributes::NullableInt40s::TypeInfo::DecodableType nullableInt40s;
+ Attributes::NullableInt48s::TypeInfo::DecodableType nullableInt48s;
+ Attributes::NullableInt56s::TypeInfo::DecodableType nullableInt56s;
+ Attributes::NullableInt64s::TypeInfo::DecodableType nullableInt64s;
+ Attributes::NullableEnum8::TypeInfo::DecodableType nullableEnum8;
+ Attributes::NullableEnum16::TypeInfo::DecodableType nullableEnum16;
+ Attributes::NullableFloatSingle::TypeInfo::DecodableType nullableFloatSingle;
+ Attributes::NullableFloatDouble::TypeInfo::DecodableType nullableFloatDouble;
+ Attributes::NullableOctetString::TypeInfo::DecodableType nullableOctetString;
+ Attributes::NullableCharString::TypeInfo::DecodableType nullableCharString;
+ Attributes::NullableEnumAttr::TypeInfo::DecodableType nullableEnumAttr;
+ Attributes::NullableStruct::TypeInfo::DecodableType nullableStruct;
+ Attributes::NullableRangeRestrictedInt8u::TypeInfo::DecodableType nullableRangeRestrictedInt8u;
+ Attributes::NullableRangeRestrictedInt8s::TypeInfo::DecodableType nullableRangeRestrictedInt8s;
+ Attributes::NullableRangeRestrictedInt16u::TypeInfo::DecodableType nullableRangeRestrictedInt16u;
+ Attributes::NullableRangeRestrictedInt16s::TypeInfo::DecodableType nullableRangeRestrictedInt16s;
+ Attributes::WriteOnlyInt8u::TypeInfo::DecodableType writeOnlyInt8u = static_cast<uint8_t>(0);
+ Attributes::NullableGlobalEnum::TypeInfo::DecodableType nullableGlobalEnum;
+ Attributes::NullableGlobalStruct::TypeInfo::DecodableType nullableGlobalStruct;
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ Attributes::MeiInt8u::TypeInfo::DecodableType meiInt8u = static_cast<uint8_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace TestEvent {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kArg1 = 1,
+ kArg2 = 2,
+ kArg3 = 3,
+ kArg4 = 4,
+ kArg5 = 5,
+ kArg6 = 6,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TestEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+ bool arg3 = static_cast<bool>(0);
+ Structs::SimpleStruct::Type arg4;
+ DataModel::List<const Structs::SimpleStruct::Type> arg5;
+ DataModel::List<const SimpleEnum> arg6;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TestEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ SimpleEnum arg2 = static_cast<SimpleEnum>(0);
+ bool arg3 = static_cast<bool>(0);
+ Structs::SimpleStruct::DecodableType arg4;
+ DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg5;
+ DataModel::DecodableList<SimpleEnum> arg6;
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TestEvent
+namespace TestFabricScopedEvent {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TestFabricScopedEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr bool kIsFabricScoped = true;
+
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TestFabricScopedEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TestFabricScopedEvent
+namespace TestDifferentVendorMeiEvent {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kArg1 = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TestDifferentVendorMeiEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::TestDifferentVendorMeiEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::UnitTesting::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace TestDifferentVendorMeiEvent
+} // namespace Events
+} // namespace UnitTesting
+namespace FaultInjection {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace FailAtFault {
+struct Type;
+struct DecodableType;
+} // namespace FailAtFault
+
+namespace FailRandomlyAtFault {
+struct Type;
+struct DecodableType;
+} // namespace FailRandomlyAtFault
+
+} // namespace Commands
+
+namespace Commands {
+namespace FailAtFault {
+enum class Fields : uint8_t
+{
+ kType = 0,
+ kId = 1,
+ kNumCallsToSkip = 2,
+ kNumCallsToFail = 3,
+ kTakeMutex = 4,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::FailAtFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+
+ FaultType type = static_cast<FaultType>(0);
+ uint32_t id = static_cast<uint32_t>(0);
+ uint32_t numCallsToSkip = static_cast<uint32_t>(0);
+ uint32_t numCallsToFail = static_cast<uint32_t>(0);
+ bool takeMutex = static_cast<bool>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::FailAtFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+
+ FaultType type = static_cast<FaultType>(0);
+ uint32_t id = static_cast<uint32_t>(0);
+ uint32_t numCallsToSkip = static_cast<uint32_t>(0);
+ uint32_t numCallsToFail = static_cast<uint32_t>(0);
+ bool takeMutex = static_cast<bool>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace FailAtFault
+namespace FailRandomlyAtFault {
+enum class Fields : uint8_t
+{
+ kType = 0,
+ kId = 1,
+ kPercentage = 2,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::FailRandomlyAtFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+
+ FaultType type = static_cast<FaultType>(0);
+ uint32_t id = static_cast<uint32_t>(0);
+ uint8_t percentage = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::FailRandomlyAtFault::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+
+ FaultType type = static_cast<FaultType>(0);
+ uint32_t id = static_cast<uint32_t>(0);
+ uint8_t percentage = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace FailRandomlyAtFault
+} // namespace Commands
+
+namespace Attributes {
+
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::FaultInjection::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+} // namespace FaultInjection
+namespace SampleManufacturerSpecific {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Ping {
+struct Type;
+struct DecodableType;
+} // namespace Ping
+
+namespace AddArgumentsResponse {
+struct Type;
+struct DecodableType;
+} // namespace AddArgumentsResponse
+
+namespace AddArguments {
+struct Type;
+struct DecodableType;
+} // namespace AddArguments
+
+} // namespace Commands
+
+namespace Commands {
+namespace Ping {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Ping::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Ping::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Ping
+namespace AddArgumentsResponse {
+enum class Fields : uint8_t
+{
+ kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddArgumentsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddArgumentsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddArgumentsResponse
+namespace AddArguments {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddArguments::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint8_t arg2 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddArguments::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint8_t arg2 = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddArguments
+} // namespace Commands
+
+namespace Attributes {
+
+namespace FlipFlop {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FlipFlop::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FlipFlop
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::FlipFlop::TypeInfo::DecodableType flipFlop = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace PingCountEvent {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCount = 1,
+ kFabricIndex = 254,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PingCountEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+ static constexpr bool kIsFabricScoped = true;
+
+ uint32_t count = static_cast<uint32_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ auto GetFabricIndex() const { return fabricIndex; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PingCountEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
+
+ uint32_t count = static_cast<uint32_t>(0);
+ chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PingCountEvent
+} // namespace Events
+} // namespace SampleManufacturerSpecific
+namespace SampleExternalManufacturerSpecific {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Ping {
+struct Type;
+struct DecodableType;
+} // namespace Ping
+
+namespace AddArgumentsResponse {
+struct Type;
+struct DecodableType;
+} // namespace AddArgumentsResponse
+
+namespace AddArguments {
+struct Type;
+struct DecodableType;
+} // namespace AddArguments
+
+} // namespace Commands
+
+namespace Commands {
+namespace Ping {
+enum class Fields : uint8_t
+{
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Ping::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Ping::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Ping
+namespace AddArgumentsResponse {
+enum class Fields : uint8_t
+{
+ kReturnValue = 0,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddArgumentsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddArgumentsResponse::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ uint8_t returnValue = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddArgumentsResponse
+namespace AddArguments {
+enum class Fields : uint8_t
+{
+ kArg1 = 0,
+ kArg2 = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::AddArguments::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint8_t arg2 = static_cast<uint8_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+
+ using ResponseType = Clusters::SampleExternalManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::AddArguments::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ uint8_t arg1 = static_cast<uint8_t>(0);
+ uint8_t arg2 = static_cast<uint8_t>(0);
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace AddArguments
+} // namespace Commands
+
+namespace Attributes {
+
+namespace FlipFlop {
+struct TypeInfo
+{
+ using Type = bool;
+ using DecodableType = bool;
+ using DecodableArgType = bool;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::FlipFlop::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace FlipFlop
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+};
+} // namespace AcceptedCommandList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::FlipFlop::TypeInfo::DecodableType flipFlop = static_cast<bool>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace PingCountEvent {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kCount = 1,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PingCountEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ uint32_t count = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::PingCountEvent::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleExternalManufacturerSpecific::Id; }
+
+ uint32_t count = static_cast<uint32_t>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace PingCountEvent
+} // namespace Events
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+
+bool CommandNeedsTimedInvoke(ClusterId aCluster, CommandId aCommand);
+bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand);
+bool CommandHasLargePayload(ClusterId aCluster, CommandId aCommand);
+
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
new file mode 100644
index 00000000000000..73b19595eda288
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
@@ -0,0 +1,7750 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <app/util/basic-types.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace Globals {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = 0x0000FFF8;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = 0x0000FFF9;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = 0x0000FFFB;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = 0x0000FFFC;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = 0x0000FFFD;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Globals
+
+namespace Identify {
+namespace Attributes {
+
+namespace IdentifyTime {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace IdentifyTime
+
+namespace IdentifyType {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace IdentifyType
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Identify
+
+namespace Groups {
+namespace Attributes {
+
+namespace NameSupport {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace NameSupport
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Groups
+
+namespace OnOff {
+namespace Attributes {
+
+namespace OnOff {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace OnOff
+
+namespace GlobalSceneControl {
+static constexpr AttributeId Id = 0x00004000;
+} // namespace GlobalSceneControl
+
+namespace OnTime {
+static constexpr AttributeId Id = 0x00004001;
+} // namespace OnTime
+
+namespace OffWaitTime {
+static constexpr AttributeId Id = 0x00004002;
+} // namespace OffWaitTime
+
+namespace StartUpOnOff {
+static constexpr AttributeId Id = 0x00004003;
+} // namespace StartUpOnOff
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OnOff
+
+namespace LevelControl {
+namespace Attributes {
+
+namespace CurrentLevel {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CurrentLevel
+
+namespace RemainingTime {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace RemainingTime
+
+namespace MinLevel {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MinLevel
+
+namespace MaxLevel {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace MaxLevel
+
+namespace CurrentFrequency {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace CurrentFrequency
+
+namespace MinFrequency {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace MinFrequency
+
+namespace MaxFrequency {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace MaxFrequency
+
+namespace Options {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace Options
+
+namespace OnOffTransitionTime {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace OnOffTransitionTime
+
+namespace OnLevel {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace OnLevel
+
+namespace OnTransitionTime {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace OnTransitionTime
+
+namespace OffTransitionTime {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace OffTransitionTime
+
+namespace DefaultMoveRate {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace DefaultMoveRate
+
+namespace StartUpCurrentLevel {
+static constexpr AttributeId Id = 0x00004000;
+} // namespace StartUpCurrentLevel
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LevelControl
+
+namespace PulseWidthModulation {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PulseWidthModulation
+
+namespace Descriptor {
+namespace Attributes {
+
+namespace DeviceTypeList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace DeviceTypeList
+
+namespace ServerList {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ServerList
+
+namespace ClientList {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ClientList
+
+namespace PartsList {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PartsList
+
+namespace TagList {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace TagList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Descriptor
+
+namespace Binding {
+namespace Attributes {
+
+namespace Binding {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Binding
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Binding
+
+namespace AccessControl {
+namespace Attributes {
+
+namespace Acl {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Acl
+
+namespace Extension {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Extension
+
+namespace SubjectsPerAccessControlEntry {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace SubjectsPerAccessControlEntry
+
+namespace TargetsPerAccessControlEntry {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace TargetsPerAccessControlEntry
+
+namespace AccessControlEntriesPerFabric {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace AccessControlEntriesPerFabric
+
+namespace CommissioningARL {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace CommissioningARL
+
+namespace Arl {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace Arl
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AccessControl
+
+namespace Actions {
+namespace Attributes {
+
+namespace ActionList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace ActionList
+
+namespace EndpointLists {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace EndpointLists
+
+namespace SetupURL {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace SetupURL
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Actions
+
+namespace BasicInformation {
+namespace Attributes {
+
+namespace DataModelRevision {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace DataModelRevision
+
+namespace VendorName {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace VendorName
+
+namespace VendorID {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace VendorID
+
+namespace ProductName {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ProductName
+
+namespace ProductID {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ProductID
+
+namespace NodeLabel {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace NodeLabel
+
+namespace Location {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace Location
+
+namespace HardwareVersion {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace HardwareVersion
+
+namespace HardwareVersionString {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace HardwareVersionString
+
+namespace SoftwareVersion {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace SoftwareVersion
+
+namespace SoftwareVersionString {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace SoftwareVersionString
+
+namespace ManufacturingDate {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace ManufacturingDate
+
+namespace PartNumber {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace PartNumber
+
+namespace ProductURL {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace ProductURL
+
+namespace ProductLabel {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace ProductLabel
+
+namespace SerialNumber {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace SerialNumber
+
+namespace LocalConfigDisabled {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace LocalConfigDisabled
+
+namespace Reachable {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace Reachable
+
+namespace UniqueID {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace UniqueID
+
+namespace CapabilityMinima {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace CapabilityMinima
+
+namespace ProductAppearance {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace ProductAppearance
+
+namespace SpecificationVersion {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace SpecificationVersion
+
+namespace MaxPathsPerInvoke {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace MaxPathsPerInvoke
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BasicInformation
+
+namespace OtaSoftwareUpdateProvider {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateProvider
+
+namespace OtaSoftwareUpdateRequestor {
+namespace Attributes {
+
+namespace DefaultOTAProviders {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace DefaultOTAProviders
+
+namespace UpdatePossible {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace UpdatePossible
+
+namespace UpdateState {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace UpdateState
+
+namespace UpdateStateProgress {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace UpdateStateProgress
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OtaSoftwareUpdateRequestor
+
+namespace LocalizationConfiguration {
+namespace Attributes {
+
+namespace ActiveLocale {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace ActiveLocale
+
+namespace SupportedLocales {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SupportedLocales
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LocalizationConfiguration
+
+namespace TimeFormatLocalization {
+namespace Attributes {
+
+namespace HourFormat {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace HourFormat
+
+namespace ActiveCalendarType {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ActiveCalendarType
+
+namespace SupportedCalendarTypes {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace SupportedCalendarTypes
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TimeFormatLocalization
+
+namespace UnitLocalization {
+namespace Attributes {
+
+namespace TemperatureUnit {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace TemperatureUnit
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace UnitLocalization
+
+namespace PowerSourceConfiguration {
+namespace Attributes {
+
+namespace Sources {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Sources
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerSourceConfiguration
+
+namespace PowerSource {
+namespace Attributes {
+
+namespace Status {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Status
+
+namespace Order {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Order
+
+namespace Description {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Description
+
+namespace WiredAssessedInputVoltage {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace WiredAssessedInputVoltage
+
+namespace WiredAssessedInputFrequency {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace WiredAssessedInputFrequency
+
+namespace WiredCurrentType {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace WiredCurrentType
+
+namespace WiredAssessedCurrent {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace WiredAssessedCurrent
+
+namespace WiredNominalVoltage {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace WiredNominalVoltage
+
+namespace WiredMaximumCurrent {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace WiredMaximumCurrent
+
+namespace WiredPresent {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace WiredPresent
+
+namespace ActiveWiredFaults {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace ActiveWiredFaults
+
+namespace BatVoltage {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace BatVoltage
+
+namespace BatPercentRemaining {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace BatPercentRemaining
+
+namespace BatTimeRemaining {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace BatTimeRemaining
+
+namespace BatChargeLevel {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace BatChargeLevel
+
+namespace BatReplacementNeeded {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace BatReplacementNeeded
+
+namespace BatReplaceability {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace BatReplaceability
+
+namespace BatPresent {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace BatPresent
+
+namespace ActiveBatFaults {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace ActiveBatFaults
+
+namespace BatReplacementDescription {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace BatReplacementDescription
+
+namespace BatCommonDesignation {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace BatCommonDesignation
+
+namespace BatANSIDesignation {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace BatANSIDesignation
+
+namespace BatIECDesignation {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace BatIECDesignation
+
+namespace BatApprovedChemistry {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace BatApprovedChemistry
+
+namespace BatCapacity {
+static constexpr AttributeId Id = 0x00000018;
+} // namespace BatCapacity
+
+namespace BatQuantity {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace BatQuantity
+
+namespace BatChargeState {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace BatChargeState
+
+namespace BatTimeToFullCharge {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace BatTimeToFullCharge
+
+namespace BatFunctionalWhileCharging {
+static constexpr AttributeId Id = 0x0000001C;
+} // namespace BatFunctionalWhileCharging
+
+namespace BatChargingCurrent {
+static constexpr AttributeId Id = 0x0000001D;
+} // namespace BatChargingCurrent
+
+namespace ActiveBatChargeFaults {
+static constexpr AttributeId Id = 0x0000001E;
+} // namespace ActiveBatChargeFaults
+
+namespace EndpointList {
+static constexpr AttributeId Id = 0x0000001F;
+} // namespace EndpointList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerSource
+
+namespace GeneralCommissioning {
+namespace Attributes {
+
+namespace Breadcrumb {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Breadcrumb
+
+namespace BasicCommissioningInfo {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace BasicCommissioningInfo
+
+namespace RegulatoryConfig {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace RegulatoryConfig
+
+namespace LocationCapability {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace LocationCapability
+
+namespace SupportsConcurrentConnection {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace SupportsConcurrentConnection
+
+namespace TCAcceptedVersion {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace TCAcceptedVersion
+
+namespace TCMinRequiredVersion {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace TCMinRequiredVersion
+
+namespace TCAcknowledgements {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace TCAcknowledgements
+
+namespace TCAcknowledgementsRequired {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace TCAcknowledgementsRequired
+
+namespace TCUpdateDeadline {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace TCUpdateDeadline
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace GeneralCommissioning
+
+namespace NetworkCommissioning {
+namespace Attributes {
+
+namespace MaxNetworks {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MaxNetworks
+
+namespace Networks {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Networks
+
+namespace ScanMaxTimeSeconds {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ScanMaxTimeSeconds
+
+namespace ConnectMaxTimeSeconds {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ConnectMaxTimeSeconds
+
+namespace InterfaceEnabled {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace InterfaceEnabled
+
+namespace LastNetworkingStatus {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace LastNetworkingStatus
+
+namespace LastNetworkID {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace LastNetworkID
+
+namespace LastConnectErrorValue {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace LastConnectErrorValue
+
+namespace SupportedWiFiBands {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace SupportedWiFiBands
+
+namespace SupportedThreadFeatures {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace SupportedThreadFeatures
+
+namespace ThreadVersion {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace ThreadVersion
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace NetworkCommissioning
+
+namespace DiagnosticLogs {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DiagnosticLogs
+
+namespace GeneralDiagnostics {
+namespace Attributes {
+
+namespace NetworkInterfaces {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace NetworkInterfaces
+
+namespace RebootCount {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace RebootCount
+
+namespace UpTime {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace UpTime
+
+namespace TotalOperationalHours {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace TotalOperationalHours
+
+namespace BootReason {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace BootReason
+
+namespace ActiveHardwareFaults {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace ActiveHardwareFaults
+
+namespace ActiveRadioFaults {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace ActiveRadioFaults
+
+namespace ActiveNetworkFaults {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace ActiveNetworkFaults
+
+namespace TestEventTriggersEnabled {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace TestEventTriggersEnabled
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace GeneralDiagnostics
+
+namespace SoftwareDiagnostics {
+namespace Attributes {
+
+namespace ThreadMetrics {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace ThreadMetrics
+
+namespace CurrentHeapFree {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentHeapFree
+
+namespace CurrentHeapUsed {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace CurrentHeapUsed
+
+namespace CurrentHeapHighWatermark {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace CurrentHeapHighWatermark
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SoftwareDiagnostics
+
+namespace ThreadNetworkDiagnostics {
+namespace Attributes {
+
+namespace Channel {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Channel
+
+namespace RoutingRole {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace RoutingRole
+
+namespace NetworkName {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace NetworkName
+
+namespace PanId {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PanId
+
+namespace ExtendedPanId {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ExtendedPanId
+
+namespace MeshLocalPrefix {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace MeshLocalPrefix
+
+namespace OverrunCount {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace OverrunCount
+
+namespace NeighborTable {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace NeighborTable
+
+namespace RouteTable {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace RouteTable
+
+namespace PartitionId {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace PartitionId
+
+namespace Weighting {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace Weighting
+
+namespace DataVersion {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace DataVersion
+
+namespace StableDataVersion {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace StableDataVersion
+
+namespace LeaderRouterId {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace LeaderRouterId
+
+namespace DetachedRoleCount {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace DetachedRoleCount
+
+namespace ChildRoleCount {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace ChildRoleCount
+
+namespace RouterRoleCount {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace RouterRoleCount
+
+namespace LeaderRoleCount {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace LeaderRoleCount
+
+namespace AttachAttemptCount {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace AttachAttemptCount
+
+namespace PartitionIdChangeCount {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace PartitionIdChangeCount
+
+namespace BetterPartitionAttachAttemptCount {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace BetterPartitionAttachAttemptCount
+
+namespace ParentChangeCount {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace ParentChangeCount
+
+namespace TxTotalCount {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace TxTotalCount
+
+namespace TxUnicastCount {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace TxUnicastCount
+
+namespace TxBroadcastCount {
+static constexpr AttributeId Id = 0x00000018;
+} // namespace TxBroadcastCount
+
+namespace TxAckRequestedCount {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace TxAckRequestedCount
+
+namespace TxAckedCount {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace TxAckedCount
+
+namespace TxNoAckRequestedCount {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace TxNoAckRequestedCount
+
+namespace TxDataCount {
+static constexpr AttributeId Id = 0x0000001C;
+} // namespace TxDataCount
+
+namespace TxDataPollCount {
+static constexpr AttributeId Id = 0x0000001D;
+} // namespace TxDataPollCount
+
+namespace TxBeaconCount {
+static constexpr AttributeId Id = 0x0000001E;
+} // namespace TxBeaconCount
+
+namespace TxBeaconRequestCount {
+static constexpr AttributeId Id = 0x0000001F;
+} // namespace TxBeaconRequestCount
+
+namespace TxOtherCount {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace TxOtherCount
+
+namespace TxRetryCount {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace TxRetryCount
+
+namespace TxDirectMaxRetryExpiryCount {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace TxDirectMaxRetryExpiryCount
+
+namespace TxIndirectMaxRetryExpiryCount {
+static constexpr AttributeId Id = 0x00000023;
+} // namespace TxIndirectMaxRetryExpiryCount
+
+namespace TxErrCcaCount {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace TxErrCcaCount
+
+namespace TxErrAbortCount {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace TxErrAbortCount
+
+namespace TxErrBusyChannelCount {
+static constexpr AttributeId Id = 0x00000026;
+} // namespace TxErrBusyChannelCount
+
+namespace RxTotalCount {
+static constexpr AttributeId Id = 0x00000027;
+} // namespace RxTotalCount
+
+namespace RxUnicastCount {
+static constexpr AttributeId Id = 0x00000028;
+} // namespace RxUnicastCount
+
+namespace RxBroadcastCount {
+static constexpr AttributeId Id = 0x00000029;
+} // namespace RxBroadcastCount
+
+namespace RxDataCount {
+static constexpr AttributeId Id = 0x0000002A;
+} // namespace RxDataCount
+
+namespace RxDataPollCount {
+static constexpr AttributeId Id = 0x0000002B;
+} // namespace RxDataPollCount
+
+namespace RxBeaconCount {
+static constexpr AttributeId Id = 0x0000002C;
+} // namespace RxBeaconCount
+
+namespace RxBeaconRequestCount {
+static constexpr AttributeId Id = 0x0000002D;
+} // namespace RxBeaconRequestCount
+
+namespace RxOtherCount {
+static constexpr AttributeId Id = 0x0000002E;
+} // namespace RxOtherCount
+
+namespace RxAddressFilteredCount {
+static constexpr AttributeId Id = 0x0000002F;
+} // namespace RxAddressFilteredCount
+
+namespace RxDestAddrFilteredCount {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace RxDestAddrFilteredCount
+
+namespace RxDuplicatedCount {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace RxDuplicatedCount
+
+namespace RxErrNoFrameCount {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace RxErrNoFrameCount
+
+namespace RxErrUnknownNeighborCount {
+static constexpr AttributeId Id = 0x00000033;
+} // namespace RxErrUnknownNeighborCount
+
+namespace RxErrInvalidSrcAddrCount {
+static constexpr AttributeId Id = 0x00000034;
+} // namespace RxErrInvalidSrcAddrCount
+
+namespace RxErrSecCount {
+static constexpr AttributeId Id = 0x00000035;
+} // namespace RxErrSecCount
+
+namespace RxErrFcsCount {
+static constexpr AttributeId Id = 0x00000036;
+} // namespace RxErrFcsCount
+
+namespace RxErrOtherCount {
+static constexpr AttributeId Id = 0x00000037;
+} // namespace RxErrOtherCount
+
+namespace ActiveTimestamp {
+static constexpr AttributeId Id = 0x00000038;
+} // namespace ActiveTimestamp
+
+namespace PendingTimestamp {
+static constexpr AttributeId Id = 0x00000039;
+} // namespace PendingTimestamp
+
+namespace Delay {
+static constexpr AttributeId Id = 0x0000003A;
+} // namespace Delay
+
+namespace SecurityPolicy {
+static constexpr AttributeId Id = 0x0000003B;
+} // namespace SecurityPolicy
+
+namespace ChannelPage0Mask {
+static constexpr AttributeId Id = 0x0000003C;
+} // namespace ChannelPage0Mask
+
+namespace OperationalDatasetComponents {
+static constexpr AttributeId Id = 0x0000003D;
+} // namespace OperationalDatasetComponents
+
+namespace ActiveNetworkFaultsList {
+static constexpr AttributeId Id = 0x0000003E;
+} // namespace ActiveNetworkFaultsList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadNetworkDiagnostics
+
+namespace WiFiNetworkDiagnostics {
+namespace Attributes {
+
+namespace Bssid {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Bssid
+
+namespace SecurityType {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SecurityType
+
+namespace WiFiVersion {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace WiFiVersion
+
+namespace ChannelNumber {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ChannelNumber
+
+namespace Rssi {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace Rssi
+
+namespace BeaconLostCount {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace BeaconLostCount
+
+namespace BeaconRxCount {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace BeaconRxCount
+
+namespace PacketMulticastRxCount {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace PacketMulticastRxCount
+
+namespace PacketMulticastTxCount {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace PacketMulticastTxCount
+
+namespace PacketUnicastRxCount {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace PacketUnicastRxCount
+
+namespace PacketUnicastTxCount {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace PacketUnicastTxCount
+
+namespace CurrentMaxRate {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace CurrentMaxRate
+
+namespace OverrunCount {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace OverrunCount
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WiFiNetworkDiagnostics
+
+namespace EthernetNetworkDiagnostics {
+namespace Attributes {
+
+namespace PHYRate {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PHYRate
+
+namespace FullDuplex {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace FullDuplex
+
+namespace PacketRxCount {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace PacketRxCount
+
+namespace PacketTxCount {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PacketTxCount
+
+namespace TxErrCount {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace TxErrCount
+
+namespace CollisionCount {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace CollisionCount
+
+namespace OverrunCount {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace OverrunCount
+
+namespace CarrierDetect {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace CarrierDetect
+
+namespace TimeSinceReset {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace TimeSinceReset
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EthernetNetworkDiagnostics
+
+namespace TimeSynchronization {
+namespace Attributes {
+
+namespace UTCTime {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace UTCTime
+
+namespace Granularity {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Granularity
+
+namespace TimeSource {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace TimeSource
+
+namespace TrustedTimeSource {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace TrustedTimeSource
+
+namespace DefaultNTP {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace DefaultNTP
+
+namespace TimeZone {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace TimeZone
+
+namespace DSTOffset {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace DSTOffset
+
+namespace LocalTime {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace LocalTime
+
+namespace TimeZoneDatabase {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace TimeZoneDatabase
+
+namespace NTPServerAvailable {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace NTPServerAvailable
+
+namespace TimeZoneListMaxSize {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace TimeZoneListMaxSize
+
+namespace DSTOffsetListMaxSize {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace DSTOffsetListMaxSize
+
+namespace SupportsDNSResolve {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace SupportsDNSResolve
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TimeSynchronization
+
+namespace BridgedDeviceBasicInformation {
+namespace Attributes {
+
+namespace VendorName {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace VendorName
+
+namespace VendorID {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace VendorID
+
+namespace ProductName {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ProductName
+
+namespace ProductID {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ProductID
+
+namespace NodeLabel {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace NodeLabel
+
+namespace HardwareVersion {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace HardwareVersion
+
+namespace HardwareVersionString {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace HardwareVersionString
+
+namespace SoftwareVersion {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace SoftwareVersion
+
+namespace SoftwareVersionString {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace SoftwareVersionString
+
+namespace ManufacturingDate {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace ManufacturingDate
+
+namespace PartNumber {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace PartNumber
+
+namespace ProductURL {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace ProductURL
+
+namespace ProductLabel {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace ProductLabel
+
+namespace SerialNumber {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace SerialNumber
+
+namespace Reachable {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace Reachable
+
+namespace UniqueID {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace UniqueID
+
+namespace ProductAppearance {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace ProductAppearance
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BridgedDeviceBasicInformation
+
+namespace Switch {
+namespace Attributes {
+
+namespace NumberOfPositions {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace NumberOfPositions
+
+namespace CurrentPosition {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentPosition
+
+namespace MultiPressMax {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MultiPressMax
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Switch
+
+namespace AdministratorCommissioning {
+namespace Attributes {
+
+namespace WindowStatus {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace WindowStatus
+
+namespace AdminFabricIndex {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace AdminFabricIndex
+
+namespace AdminVendorId {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace AdminVendorId
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AdministratorCommissioning
+
+namespace OperationalCredentials {
+namespace Attributes {
+
+namespace NOCs {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace NOCs
+
+namespace Fabrics {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Fabrics
+
+namespace SupportedFabrics {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace SupportedFabrics
+
+namespace CommissionedFabrics {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace CommissionedFabrics
+
+namespace TrustedRootCertificates {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace TrustedRootCertificates
+
+namespace CurrentFabricIndex {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace CurrentFabricIndex
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OperationalCredentials
+
+namespace GroupKeyManagement {
+namespace Attributes {
+
+namespace GroupKeyMap {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace GroupKeyMap
+
+namespace GroupTable {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace GroupTable
+
+namespace MaxGroupsPerFabric {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxGroupsPerFabric
+
+namespace MaxGroupKeysPerFabric {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace MaxGroupKeysPerFabric
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace GroupKeyManagement
+
+namespace FixedLabel {
+namespace Attributes {
+
+namespace LabelList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace LabelList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FixedLabel
+
+namespace UserLabel {
+namespace Attributes {
+
+namespace LabelList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace LabelList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace UserLabel
+
+namespace ProxyConfiguration {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyConfiguration
+
+namespace ProxyDiscovery {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyDiscovery
+
+namespace ProxyValid {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ProxyValid
+
+namespace BooleanState {
+namespace Attributes {
+
+namespace StateValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace StateValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BooleanState
+
+namespace IcdManagement {
+namespace Attributes {
+
+namespace IdleModeDuration {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace IdleModeDuration
+
+namespace ActiveModeDuration {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ActiveModeDuration
+
+namespace ActiveModeThreshold {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ActiveModeThreshold
+
+namespace RegisteredClients {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace RegisteredClients
+
+namespace ICDCounter {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ICDCounter
+
+namespace ClientsSupportedPerFabric {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace ClientsSupportedPerFabric
+
+namespace UserActiveModeTriggerHint {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace UserActiveModeTriggerHint
+
+namespace UserActiveModeTriggerInstruction {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace UserActiveModeTriggerInstruction
+
+namespace OperatingMode {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace OperatingMode
+
+namespace MaximumCheckInBackOff {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MaximumCheckInBackOff
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace IcdManagement
+
+namespace Timer {
+namespace Attributes {
+
+namespace SetTime {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SetTime
+
+namespace TimeRemaining {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace TimeRemaining
+
+namespace TimerState {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace TimerState
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Timer
+
+namespace OvenCavityOperationalState {
+namespace Attributes {
+
+namespace PhaseList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PhaseList
+
+namespace CurrentPhase {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentPhase
+
+namespace CountdownTime {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace CountdownTime
+
+namespace OperationalStateList {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OperationalStateList
+
+namespace OperationalState {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace OperationalState
+
+namespace OperationalError {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace OperationalError
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OvenCavityOperationalState
+
+namespace OvenMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace StartUpMode {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace StartUpMode
+
+namespace OnMode {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OnMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OvenMode
+
+namespace LaundryDryerControls {
+namespace Attributes {
+
+namespace SupportedDrynessLevels {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedDrynessLevels
+
+namespace SelectedDrynessLevel {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SelectedDrynessLevel
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryDryerControls
+
+namespace ModeSelect {
+namespace Attributes {
+
+namespace Description {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Description
+
+namespace StandardNamespace {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace StandardNamespace
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace CurrentMode
+
+namespace StartUpMode {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace StartUpMode
+
+namespace OnMode {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace OnMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ModeSelect
+
+namespace LaundryWasherMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace StartUpMode {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace StartUpMode
+
+namespace OnMode {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OnMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryWasherMode
+
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace StartUpMode {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace StartUpMode
+
+namespace OnMode {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OnMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+
+namespace LaundryWasherControls {
+namespace Attributes {
+
+namespace SpinSpeeds {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SpinSpeeds
+
+namespace SpinSpeedCurrent {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SpinSpeedCurrent
+
+namespace NumberOfRinses {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace NumberOfRinses
+
+namespace SupportedRinses {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace SupportedRinses
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LaundryWasherControls
+
+namespace RvcRunMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcRunMode
+
+namespace RvcCleanMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcCleanMode
+
+namespace TemperatureControl {
+namespace Attributes {
+
+namespace TemperatureSetpoint {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace TemperatureSetpoint
+
+namespace MinTemperature {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinTemperature
+
+namespace MaxTemperature {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxTemperature
+
+namespace Step {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Step
+
+namespace SelectedTemperatureLevel {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace SelectedTemperatureLevel
+
+namespace SupportedTemperatureLevels {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace SupportedTemperatureLevels
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TemperatureControl
+
+namespace RefrigeratorAlarm {
+namespace Attributes {
+
+namespace Mask {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Mask
+
+namespace State {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace State
+
+namespace Supported {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Supported
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAlarm
+
+namespace DishwasherMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace StartUpMode {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace StartUpMode
+
+namespace OnMode {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OnMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DishwasherMode
+
+namespace AirQuality {
+namespace Attributes {
+
+namespace AirQuality {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace AirQuality
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AirQuality
+
+namespace SmokeCoAlarm {
+namespace Attributes {
+
+namespace ExpressedState {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace ExpressedState
+
+namespace SmokeState {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SmokeState
+
+namespace COState {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace COState
+
+namespace BatteryAlert {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace BatteryAlert
+
+namespace DeviceMuted {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace DeviceMuted
+
+namespace TestInProgress {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace TestInProgress
+
+namespace HardwareFaultAlert {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace HardwareFaultAlert
+
+namespace EndOfServiceAlert {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace EndOfServiceAlert
+
+namespace InterconnectSmokeAlarm {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace InterconnectSmokeAlarm
+
+namespace InterconnectCOAlarm {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace InterconnectCOAlarm
+
+namespace ContaminationState {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace ContaminationState
+
+namespace SmokeSensitivityLevel {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace SmokeSensitivityLevel
+
+namespace ExpiryDate {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace ExpiryDate
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SmokeCoAlarm
+
+namespace DishwasherAlarm {
+namespace Attributes {
+
+namespace Mask {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Mask
+
+namespace Latch {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Latch
+
+namespace State {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace State
+
+namespace Supported {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Supported
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DishwasherAlarm
+
+namespace MicrowaveOvenMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MicrowaveOvenMode
+
+namespace MicrowaveOvenControl {
+namespace Attributes {
+
+namespace CookTime {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CookTime
+
+namespace MaxCookTime {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MaxCookTime
+
+namespace PowerSetting {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace PowerSetting
+
+namespace MinPower {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace MinPower
+
+namespace MaxPower {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace MaxPower
+
+namespace PowerStep {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace PowerStep
+
+namespace SupportedWatts {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace SupportedWatts
+
+namespace SelectedWattIndex {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace SelectedWattIndex
+
+namespace WattRating {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace WattRating
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MicrowaveOvenControl
+
+namespace OperationalState {
+namespace Attributes {
+
+namespace PhaseList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PhaseList
+
+namespace CurrentPhase {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentPhase
+
+namespace CountdownTime {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace CountdownTime
+
+namespace OperationalStateList {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OperationalStateList
+
+namespace OperationalState {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace OperationalState
+
+namespace OperationalError {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace OperationalError
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OperationalState
+
+namespace RvcOperationalState {
+namespace Attributes {
+
+namespace PhaseList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PhaseList
+
+namespace CurrentPhase {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentPhase
+
+namespace CountdownTime {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace CountdownTime
+
+namespace OperationalStateList {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace OperationalStateList
+
+namespace OperationalState {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace OperationalState
+
+namespace OperationalError {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace OperationalError
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RvcOperationalState
+
+namespace ScenesManagement {
+namespace Attributes {
+
+namespace LastConfiguredBy {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace LastConfiguredBy
+
+namespace SceneTableSize {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SceneTableSize
+
+namespace FabricSceneInfo {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace FabricSceneInfo
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ScenesManagement
+
+namespace HepaFilterMonitoring {
+namespace Attributes {
+
+namespace Condition {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Condition
+
+namespace DegradationDirection {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace DegradationDirection
+
+namespace ChangeIndication {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ChangeIndication
+
+namespace InPlaceIndicator {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace InPlaceIndicator
+
+namespace LastChangedTime {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace LastChangedTime
+
+namespace ReplacementProductList {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace ReplacementProductList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace HepaFilterMonitoring
+
+namespace ActivatedCarbonFilterMonitoring {
+namespace Attributes {
+
+namespace Condition {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Condition
+
+namespace DegradationDirection {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace DegradationDirection
+
+namespace ChangeIndication {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ChangeIndication
+
+namespace InPlaceIndicator {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace InPlaceIndicator
+
+namespace LastChangedTime {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace LastChangedTime
+
+namespace ReplacementProductList {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace ReplacementProductList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ActivatedCarbonFilterMonitoring
+
+namespace BooleanStateConfiguration {
+namespace Attributes {
+
+namespace CurrentSensitivityLevel {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CurrentSensitivityLevel
+
+namespace SupportedSensitivityLevels {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SupportedSensitivityLevels
+
+namespace DefaultSensitivityLevel {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace DefaultSensitivityLevel
+
+namespace AlarmsActive {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace AlarmsActive
+
+namespace AlarmsSuppressed {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace AlarmsSuppressed
+
+namespace AlarmsEnabled {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AlarmsEnabled
+
+namespace AlarmsSupported {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AlarmsSupported
+
+namespace SensorFault {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace SensorFault
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BooleanStateConfiguration
+
+namespace ValveConfigurationAndControl {
+namespace Attributes {
+
+namespace OpenDuration {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace OpenDuration
+
+namespace DefaultOpenDuration {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace DefaultOpenDuration
+
+namespace AutoCloseTime {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace AutoCloseTime
+
+namespace RemainingDuration {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace RemainingDuration
+
+namespace CurrentState {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace CurrentState
+
+namespace TargetState {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace TargetState
+
+namespace CurrentLevel {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace CurrentLevel
+
+namespace TargetLevel {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace TargetLevel
+
+namespace DefaultOpenLevel {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace DefaultOpenLevel
+
+namespace ValveFault {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace ValveFault
+
+namespace LevelStep {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelStep
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ValveConfigurationAndControl
+
+namespace ElectricalPowerMeasurement {
+namespace Attributes {
+
+namespace PowerMode {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PowerMode
+
+namespace NumberOfMeasurementTypes {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace NumberOfMeasurementTypes
+
+namespace Accuracy {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Accuracy
+
+namespace Ranges {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Ranges
+
+namespace Voltage {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace Voltage
+
+namespace ActiveCurrent {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace ActiveCurrent
+
+namespace ReactiveCurrent {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace ReactiveCurrent
+
+namespace ApparentCurrent {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace ApparentCurrent
+
+namespace ActivePower {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace ActivePower
+
+namespace ReactivePower {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace ReactivePower
+
+namespace ApparentPower {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace ApparentPower
+
+namespace RMSVoltage {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace RMSVoltage
+
+namespace RMSCurrent {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace RMSCurrent
+
+namespace RMSPower {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace RMSPower
+
+namespace Frequency {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace Frequency
+
+namespace HarmonicCurrents {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace HarmonicCurrents
+
+namespace HarmonicPhases {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace HarmonicPhases
+
+namespace PowerFactor {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace PowerFactor
+
+namespace NeutralCurrent {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace NeutralCurrent
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ElectricalPowerMeasurement
+
+namespace ElectricalEnergyMeasurement {
+namespace Attributes {
+
+namespace Accuracy {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Accuracy
+
+namespace CumulativeEnergyImported {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CumulativeEnergyImported
+
+namespace CumulativeEnergyExported {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace CumulativeEnergyExported
+
+namespace PeriodicEnergyImported {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeriodicEnergyImported
+
+namespace PeriodicEnergyExported {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeriodicEnergyExported
+
+namespace CumulativeEnergyReset {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace CumulativeEnergyReset
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ElectricalEnergyMeasurement
+
+namespace WaterHeaterManagement {
+namespace Attributes {
+
+namespace HeaterTypes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace HeaterTypes
+
+namespace HeatDemand {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace HeatDemand
+
+namespace TankVolume {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace TankVolume
+
+namespace EstimatedHeatRequired {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace EstimatedHeatRequired
+
+namespace TankPercentage {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace TankPercentage
+
+namespace BoostState {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace BoostState
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WaterHeaterManagement
+
+namespace DemandResponseLoadControl {
+namespace Attributes {
+
+namespace LoadControlPrograms {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace LoadControlPrograms
+
+namespace NumberOfLoadControlPrograms {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace NumberOfLoadControlPrograms
+
+namespace Events {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Events
+
+namespace ActiveEvents {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ActiveEvents
+
+namespace NumberOfEventsPerProgram {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace NumberOfEventsPerProgram
+
+namespace NumberOfTransitions {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace NumberOfTransitions
+
+namespace DefaultRandomStart {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace DefaultRandomStart
+
+namespace DefaultRandomDuration {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace DefaultRandomDuration
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DemandResponseLoadControl
+
+namespace Messages {
+namespace Attributes {
+
+namespace Messages {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Messages
+
+namespace ActiveMessageIDs {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ActiveMessageIDs
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Messages
+
+namespace DeviceEnergyManagement {
+namespace Attributes {
+
+namespace ESAType {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace ESAType
+
+namespace ESACanGenerate {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ESACanGenerate
+
+namespace ESAState {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ESAState
+
+namespace AbsMinPower {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace AbsMinPower
+
+namespace AbsMaxPower {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace AbsMaxPower
+
+namespace PowerAdjustmentCapability {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace PowerAdjustmentCapability
+
+namespace Forecast {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace Forecast
+
+namespace OptOutState {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace OptOutState
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DeviceEnergyManagement
+
+namespace EnergyEvse {
+namespace Attributes {
+
+namespace State {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace State
+
+namespace SupplyState {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SupplyState
+
+namespace FaultState {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace FaultState
+
+namespace ChargingEnabledUntil {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ChargingEnabledUntil
+
+namespace DischargingEnabledUntil {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace DischargingEnabledUntil
+
+namespace CircuitCapacity {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace CircuitCapacity
+
+namespace MinimumChargeCurrent {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace MinimumChargeCurrent
+
+namespace MaximumChargeCurrent {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace MaximumChargeCurrent
+
+namespace MaximumDischargeCurrent {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MaximumDischargeCurrent
+
+namespace UserMaximumChargeCurrent {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace UserMaximumChargeCurrent
+
+namespace RandomizationDelayWindow {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace RandomizationDelayWindow
+
+namespace NextChargeStartTime {
+static constexpr AttributeId Id = 0x00000023;
+} // namespace NextChargeStartTime
+
+namespace NextChargeTargetTime {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace NextChargeTargetTime
+
+namespace NextChargeRequiredEnergy {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace NextChargeRequiredEnergy
+
+namespace NextChargeTargetSoC {
+static constexpr AttributeId Id = 0x00000026;
+} // namespace NextChargeTargetSoC
+
+namespace ApproximateEVEfficiency {
+static constexpr AttributeId Id = 0x00000027;
+} // namespace ApproximateEVEfficiency
+
+namespace StateOfCharge {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace StateOfCharge
+
+namespace BatteryCapacity {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace BatteryCapacity
+
+namespace VehicleID {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace VehicleID
+
+namespace SessionID {
+static constexpr AttributeId Id = 0x00000040;
+} // namespace SessionID
+
+namespace SessionDuration {
+static constexpr AttributeId Id = 0x00000041;
+} // namespace SessionDuration
+
+namespace SessionEnergyCharged {
+static constexpr AttributeId Id = 0x00000042;
+} // namespace SessionEnergyCharged
+
+namespace SessionEnergyDischarged {
+static constexpr AttributeId Id = 0x00000043;
+} // namespace SessionEnergyDischarged
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyEvse
+
+namespace EnergyPreference {
+namespace Attributes {
+
+namespace EnergyBalances {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace EnergyBalances
+
+namespace CurrentEnergyBalance {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentEnergyBalance
+
+namespace EnergyPriorities {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace EnergyPriorities
+
+namespace LowPowerModeSensitivities {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace LowPowerModeSensitivities
+
+namespace CurrentLowPowerModeSensitivity {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace CurrentLowPowerModeSensitivity
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyPreference
+
+namespace PowerTopology {
+namespace Attributes {
+
+namespace AvailableEndpoints {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace AvailableEndpoints
+
+namespace ActiveEndpoints {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ActiveEndpoints
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PowerTopology
+
+namespace EnergyEvseMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EnergyEvseMode
+
+namespace WaterHeaterMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WaterHeaterMode
+
+namespace DeviceEnergyManagementMode {
+namespace Attributes {
+
+namespace SupportedModes {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedModes
+
+namespace CurrentMode {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DeviceEnergyManagementMode
+
+namespace DoorLock {
+namespace Attributes {
+
+namespace LockState {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace LockState
+
+namespace LockType {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace LockType
+
+namespace ActuatorEnabled {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ActuatorEnabled
+
+namespace DoorState {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace DoorState
+
+namespace DoorOpenEvents {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace DoorOpenEvents
+
+namespace DoorClosedEvents {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace DoorClosedEvents
+
+namespace OpenPeriod {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace OpenPeriod
+
+namespace NumberOfTotalUsersSupported {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace NumberOfTotalUsersSupported
+
+namespace NumberOfPINUsersSupported {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace NumberOfPINUsersSupported
+
+namespace NumberOfRFIDUsersSupported {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace NumberOfRFIDUsersSupported
+
+namespace NumberOfWeekDaySchedulesSupportedPerUser {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace NumberOfWeekDaySchedulesSupportedPerUser
+
+namespace NumberOfYearDaySchedulesSupportedPerUser {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace NumberOfYearDaySchedulesSupportedPerUser
+
+namespace NumberOfHolidaySchedulesSupported {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace NumberOfHolidaySchedulesSupported
+
+namespace MaxPINCodeLength {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace MaxPINCodeLength
+
+namespace MinPINCodeLength {
+static constexpr AttributeId Id = 0x00000018;
+} // namespace MinPINCodeLength
+
+namespace MaxRFIDCodeLength {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace MaxRFIDCodeLength
+
+namespace MinRFIDCodeLength {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace MinRFIDCodeLength
+
+namespace CredentialRulesSupport {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace CredentialRulesSupport
+
+namespace NumberOfCredentialsSupportedPerUser {
+static constexpr AttributeId Id = 0x0000001C;
+} // namespace NumberOfCredentialsSupportedPerUser
+
+namespace Language {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace Language
+
+namespace LEDSettings {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace LEDSettings
+
+namespace AutoRelockTime {
+static constexpr AttributeId Id = 0x00000023;
+} // namespace AutoRelockTime
+
+namespace SoundVolume {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace SoundVolume
+
+namespace OperatingMode {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace OperatingMode
+
+namespace SupportedOperatingModes {
+static constexpr AttributeId Id = 0x00000026;
+} // namespace SupportedOperatingModes
+
+namespace DefaultConfigurationRegister {
+static constexpr AttributeId Id = 0x00000027;
+} // namespace DefaultConfigurationRegister
+
+namespace EnableLocalProgramming {
+static constexpr AttributeId Id = 0x00000028;
+} // namespace EnableLocalProgramming
+
+namespace EnableOneTouchLocking {
+static constexpr AttributeId Id = 0x00000029;
+} // namespace EnableOneTouchLocking
+
+namespace EnableInsideStatusLED {
+static constexpr AttributeId Id = 0x0000002A;
+} // namespace EnableInsideStatusLED
+
+namespace EnablePrivacyModeButton {
+static constexpr AttributeId Id = 0x0000002B;
+} // namespace EnablePrivacyModeButton
+
+namespace LocalProgrammingFeatures {
+static constexpr AttributeId Id = 0x0000002C;
+} // namespace LocalProgrammingFeatures
+
+namespace WrongCodeEntryLimit {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace WrongCodeEntryLimit
+
+namespace UserCodeTemporaryDisableTime {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace UserCodeTemporaryDisableTime
+
+namespace SendPINOverTheAir {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace SendPINOverTheAir
+
+namespace RequirePINforRemoteOperation {
+static constexpr AttributeId Id = 0x00000033;
+} // namespace RequirePINforRemoteOperation
+
+namespace ExpiringUserTimeout {
+static constexpr AttributeId Id = 0x00000035;
+} // namespace ExpiringUserTimeout
+
+namespace AliroReaderVerificationKey {
+static constexpr AttributeId Id = 0x00000080;
+} // namespace AliroReaderVerificationKey
+
+namespace AliroReaderGroupIdentifier {
+static constexpr AttributeId Id = 0x00000081;
+} // namespace AliroReaderGroupIdentifier
+
+namespace AliroReaderGroupSubIdentifier {
+static constexpr AttributeId Id = 0x00000082;
+} // namespace AliroReaderGroupSubIdentifier
+
+namespace AliroExpeditedTransactionSupportedProtocolVersions {
+static constexpr AttributeId Id = 0x00000083;
+} // namespace AliroExpeditedTransactionSupportedProtocolVersions
+
+namespace AliroGroupResolvingKey {
+static constexpr AttributeId Id = 0x00000084;
+} // namespace AliroGroupResolvingKey
+
+namespace AliroSupportedBLEUWBProtocolVersions {
+static constexpr AttributeId Id = 0x00000085;
+} // namespace AliroSupportedBLEUWBProtocolVersions
+
+namespace AliroBLEAdvertisingVersion {
+static constexpr AttributeId Id = 0x00000086;
+} // namespace AliroBLEAdvertisingVersion
+
+namespace NumberOfAliroCredentialIssuerKeysSupported {
+static constexpr AttributeId Id = 0x00000087;
+} // namespace NumberOfAliroCredentialIssuerKeysSupported
+
+namespace NumberOfAliroEndpointKeysSupported {
+static constexpr AttributeId Id = 0x00000088;
+} // namespace NumberOfAliroEndpointKeysSupported
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace DoorLock
+
+namespace WindowCovering {
+namespace Attributes {
+
+namespace Type {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Type
+
+namespace PhysicalClosedLimitLift {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace PhysicalClosedLimitLift
+
+namespace PhysicalClosedLimitTilt {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace PhysicalClosedLimitTilt
+
+namespace CurrentPositionLift {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace CurrentPositionLift
+
+namespace CurrentPositionTilt {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace CurrentPositionTilt
+
+namespace NumberOfActuationsLift {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace NumberOfActuationsLift
+
+namespace NumberOfActuationsTilt {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace NumberOfActuationsTilt
+
+namespace ConfigStatus {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace ConfigStatus
+
+namespace CurrentPositionLiftPercentage {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace CurrentPositionLiftPercentage
+
+namespace CurrentPositionTiltPercentage {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace CurrentPositionTiltPercentage
+
+namespace OperationalStatus {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace OperationalStatus
+
+namespace TargetPositionLiftPercent100ths {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace TargetPositionLiftPercent100ths
+
+namespace TargetPositionTiltPercent100ths {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace TargetPositionTiltPercent100ths
+
+namespace EndProductType {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace EndProductType
+
+namespace CurrentPositionLiftPercent100ths {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace CurrentPositionLiftPercent100ths
+
+namespace CurrentPositionTiltPercent100ths {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace CurrentPositionTiltPercent100ths
+
+namespace InstalledOpenLimitLift {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace InstalledOpenLimitLift
+
+namespace InstalledClosedLimitLift {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace InstalledClosedLimitLift
+
+namespace InstalledOpenLimitTilt {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace InstalledOpenLimitTilt
+
+namespace InstalledClosedLimitTilt {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace InstalledClosedLimitTilt
+
+namespace Mode {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace Mode
+
+namespace SafetyStatus {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace SafetyStatus
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WindowCovering
+
+namespace ServiceArea {
+namespace Attributes {
+
+namespace SupportedAreas {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedAreas
+
+namespace SupportedMaps {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SupportedMaps
+
+namespace SelectedAreas {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace SelectedAreas
+
+namespace CurrentArea {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace CurrentArea
+
+namespace EstimatedEndTime {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace EstimatedEndTime
+
+namespace Progress {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace Progress
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ServiceArea
+
+namespace PumpConfigurationAndControl {
+namespace Attributes {
+
+namespace MaxPressure {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MaxPressure
+
+namespace MaxSpeed {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MaxSpeed
+
+namespace MaxFlow {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxFlow
+
+namespace MinConstPressure {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace MinConstPressure
+
+namespace MaxConstPressure {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace MaxConstPressure
+
+namespace MinCompPressure {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace MinCompPressure
+
+namespace MaxCompPressure {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace MaxCompPressure
+
+namespace MinConstSpeed {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace MinConstSpeed
+
+namespace MaxConstSpeed {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MaxConstSpeed
+
+namespace MinConstFlow {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MinConstFlow
+
+namespace MaxConstFlow {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace MaxConstFlow
+
+namespace MinConstTemp {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace MinConstTemp
+
+namespace MaxConstTemp {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace MaxConstTemp
+
+namespace PumpStatus {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace PumpStatus
+
+namespace EffectiveOperationMode {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace EffectiveOperationMode
+
+namespace EffectiveControlMode {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace EffectiveControlMode
+
+namespace Capacity {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace Capacity
+
+namespace Speed {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace Speed
+
+namespace LifetimeRunningHours {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace LifetimeRunningHours
+
+namespace Power {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace Power
+
+namespace LifetimeEnergyConsumed {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace LifetimeEnergyConsumed
+
+namespace OperationMode {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace OperationMode
+
+namespace ControlMode {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace ControlMode
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PumpConfigurationAndControl
+
+namespace Thermostat {
+namespace Attributes {
+
+namespace LocalTemperature {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace LocalTemperature
+
+namespace OutdoorTemperature {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace OutdoorTemperature
+
+namespace Occupancy {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Occupancy
+
+namespace AbsMinHeatSetpointLimit {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace AbsMinHeatSetpointLimit
+
+namespace AbsMaxHeatSetpointLimit {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace AbsMaxHeatSetpointLimit
+
+namespace AbsMinCoolSetpointLimit {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AbsMinCoolSetpointLimit
+
+namespace AbsMaxCoolSetpointLimit {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AbsMaxCoolSetpointLimit
+
+namespace PICoolingDemand {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace PICoolingDemand
+
+namespace PIHeatingDemand {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace PIHeatingDemand
+
+namespace HVACSystemTypeConfiguration {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace HVACSystemTypeConfiguration
+
+namespace LocalTemperatureCalibration {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace LocalTemperatureCalibration
+
+namespace OccupiedCoolingSetpoint {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace OccupiedCoolingSetpoint
+
+namespace OccupiedHeatingSetpoint {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace OccupiedHeatingSetpoint
+
+namespace UnoccupiedCoolingSetpoint {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace UnoccupiedCoolingSetpoint
+
+namespace UnoccupiedHeatingSetpoint {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace UnoccupiedHeatingSetpoint
+
+namespace MinHeatSetpointLimit {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace MinHeatSetpointLimit
+
+namespace MaxHeatSetpointLimit {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace MaxHeatSetpointLimit
+
+namespace MinCoolSetpointLimit {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace MinCoolSetpointLimit
+
+namespace MaxCoolSetpointLimit {
+static constexpr AttributeId Id = 0x00000018;
+} // namespace MaxCoolSetpointLimit
+
+namespace MinSetpointDeadBand {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace MinSetpointDeadBand
+
+namespace RemoteSensing {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace RemoteSensing
+
+namespace ControlSequenceOfOperation {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace ControlSequenceOfOperation
+
+namespace SystemMode {
+static constexpr AttributeId Id = 0x0000001C;
+} // namespace SystemMode
+
+namespace ThermostatRunningMode {
+static constexpr AttributeId Id = 0x0000001E;
+} // namespace ThermostatRunningMode
+
+namespace StartOfWeek {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace StartOfWeek
+
+namespace NumberOfWeeklyTransitions {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace NumberOfWeeklyTransitions
+
+namespace NumberOfDailyTransitions {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace NumberOfDailyTransitions
+
+namespace TemperatureSetpointHold {
+static constexpr AttributeId Id = 0x00000023;
+} // namespace TemperatureSetpointHold
+
+namespace TemperatureSetpointHoldDuration {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace TemperatureSetpointHoldDuration
+
+namespace ThermostatProgrammingOperationMode {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace ThermostatProgrammingOperationMode
+
+namespace ThermostatRunningState {
+static constexpr AttributeId Id = 0x00000029;
+} // namespace ThermostatRunningState
+
+namespace SetpointChangeSource {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace SetpointChangeSource
+
+namespace SetpointChangeAmount {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace SetpointChangeAmount
+
+namespace SetpointChangeSourceTimestamp {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace SetpointChangeSourceTimestamp
+
+namespace OccupiedSetback {
+static constexpr AttributeId Id = 0x00000034;
+} // namespace OccupiedSetback
+
+namespace OccupiedSetbackMin {
+static constexpr AttributeId Id = 0x00000035;
+} // namespace OccupiedSetbackMin
+
+namespace OccupiedSetbackMax {
+static constexpr AttributeId Id = 0x00000036;
+} // namespace OccupiedSetbackMax
+
+namespace UnoccupiedSetback {
+static constexpr AttributeId Id = 0x00000037;
+} // namespace UnoccupiedSetback
+
+namespace UnoccupiedSetbackMin {
+static constexpr AttributeId Id = 0x00000038;
+} // namespace UnoccupiedSetbackMin
+
+namespace UnoccupiedSetbackMax {
+static constexpr AttributeId Id = 0x00000039;
+} // namespace UnoccupiedSetbackMax
+
+namespace EmergencyHeatDelta {
+static constexpr AttributeId Id = 0x0000003A;
+} // namespace EmergencyHeatDelta
+
+namespace ACType {
+static constexpr AttributeId Id = 0x00000040;
+} // namespace ACType
+
+namespace ACCapacity {
+static constexpr AttributeId Id = 0x00000041;
+} // namespace ACCapacity
+
+namespace ACRefrigerantType {
+static constexpr AttributeId Id = 0x00000042;
+} // namespace ACRefrigerantType
+
+namespace ACCompressorType {
+static constexpr AttributeId Id = 0x00000043;
+} // namespace ACCompressorType
+
+namespace ACErrorCode {
+static constexpr AttributeId Id = 0x00000044;
+} // namespace ACErrorCode
+
+namespace ACLouverPosition {
+static constexpr AttributeId Id = 0x00000045;
+} // namespace ACLouverPosition
+
+namespace ACCoilTemperature {
+static constexpr AttributeId Id = 0x00000046;
+} // namespace ACCoilTemperature
+
+namespace ACCapacityformat {
+static constexpr AttributeId Id = 0x00000047;
+} // namespace ACCapacityformat
+
+namespace PresetTypes {
+static constexpr AttributeId Id = 0x00000048;
+} // namespace PresetTypes
+
+namespace ScheduleTypes {
+static constexpr AttributeId Id = 0x00000049;
+} // namespace ScheduleTypes
+
+namespace NumberOfPresets {
+static constexpr AttributeId Id = 0x0000004A;
+} // namespace NumberOfPresets
+
+namespace NumberOfSchedules {
+static constexpr AttributeId Id = 0x0000004B;
+} // namespace NumberOfSchedules
+
+namespace NumberOfScheduleTransitions {
+static constexpr AttributeId Id = 0x0000004C;
+} // namespace NumberOfScheduleTransitions
+
+namespace NumberOfScheduleTransitionPerDay {
+static constexpr AttributeId Id = 0x0000004D;
+} // namespace NumberOfScheduleTransitionPerDay
+
+namespace ActivePresetHandle {
+static constexpr AttributeId Id = 0x0000004E;
+} // namespace ActivePresetHandle
+
+namespace ActiveScheduleHandle {
+static constexpr AttributeId Id = 0x0000004F;
+} // namespace ActiveScheduleHandle
+
+namespace Presets {
+static constexpr AttributeId Id = 0x00000050;
+} // namespace Presets
+
+namespace Schedules {
+static constexpr AttributeId Id = 0x00000051;
+} // namespace Schedules
+
+namespace SetpointHoldExpiryTimestamp {
+static constexpr AttributeId Id = 0x00000052;
+} // namespace SetpointHoldExpiryTimestamp
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Thermostat
+
+namespace FanControl {
+namespace Attributes {
+
+namespace FanMode {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace FanMode
+
+namespace FanModeSequence {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace FanModeSequence
+
+namespace PercentSetting {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace PercentSetting
+
+namespace PercentCurrent {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PercentCurrent
+
+namespace SpeedMax {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace SpeedMax
+
+namespace SpeedSetting {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace SpeedSetting
+
+namespace SpeedCurrent {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace SpeedCurrent
+
+namespace RockSupport {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace RockSupport
+
+namespace RockSetting {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace RockSetting
+
+namespace WindSupport {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace WindSupport
+
+namespace WindSetting {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace WindSetting
+
+namespace AirflowDirection {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace AirflowDirection
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FanControl
+
+namespace ThermostatUserInterfaceConfiguration {
+namespace Attributes {
+
+namespace TemperatureDisplayMode {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace TemperatureDisplayMode
+
+namespace KeypadLockout {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace KeypadLockout
+
+namespace ScheduleProgrammingVisibility {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ScheduleProgrammingVisibility
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThermostatUserInterfaceConfiguration
+
+namespace ColorControl {
+namespace Attributes {
+
+namespace CurrentHue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CurrentHue
+
+namespace CurrentSaturation {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentSaturation
+
+namespace RemainingTime {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace RemainingTime
+
+namespace CurrentX {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace CurrentX
+
+namespace CurrentY {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace CurrentY
+
+namespace DriftCompensation {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace DriftCompensation
+
+namespace CompensationText {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace CompensationText
+
+namespace ColorTemperatureMireds {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace ColorTemperatureMireds
+
+namespace ColorMode {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace ColorMode
+
+namespace Options {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace Options
+
+namespace NumberOfPrimaries {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace NumberOfPrimaries
+
+namespace Primary1X {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace Primary1X
+
+namespace Primary1Y {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace Primary1Y
+
+namespace Primary1Intensity {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace Primary1Intensity
+
+namespace Primary2X {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace Primary2X
+
+namespace Primary2Y {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace Primary2Y
+
+namespace Primary2Intensity {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace Primary2Intensity
+
+namespace Primary3X {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace Primary3X
+
+namespace Primary3Y {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace Primary3Y
+
+namespace Primary3Intensity {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace Primary3Intensity
+
+namespace Primary4X {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace Primary4X
+
+namespace Primary4Y {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace Primary4Y
+
+namespace Primary4Intensity {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace Primary4Intensity
+
+namespace Primary5X {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace Primary5X
+
+namespace Primary5Y {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace Primary5Y
+
+namespace Primary5Intensity {
+static constexpr AttributeId Id = 0x00000026;
+} // namespace Primary5Intensity
+
+namespace Primary6X {
+static constexpr AttributeId Id = 0x00000028;
+} // namespace Primary6X
+
+namespace Primary6Y {
+static constexpr AttributeId Id = 0x00000029;
+} // namespace Primary6Y
+
+namespace Primary6Intensity {
+static constexpr AttributeId Id = 0x0000002A;
+} // namespace Primary6Intensity
+
+namespace WhitePointX {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace WhitePointX
+
+namespace WhitePointY {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace WhitePointY
+
+namespace ColorPointRX {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace ColorPointRX
+
+namespace ColorPointRY {
+static constexpr AttributeId Id = 0x00000033;
+} // namespace ColorPointRY
+
+namespace ColorPointRIntensity {
+static constexpr AttributeId Id = 0x00000034;
+} // namespace ColorPointRIntensity
+
+namespace ColorPointGX {
+static constexpr AttributeId Id = 0x00000036;
+} // namespace ColorPointGX
+
+namespace ColorPointGY {
+static constexpr AttributeId Id = 0x00000037;
+} // namespace ColorPointGY
+
+namespace ColorPointGIntensity {
+static constexpr AttributeId Id = 0x00000038;
+} // namespace ColorPointGIntensity
+
+namespace ColorPointBX {
+static constexpr AttributeId Id = 0x0000003A;
+} // namespace ColorPointBX
+
+namespace ColorPointBY {
+static constexpr AttributeId Id = 0x0000003B;
+} // namespace ColorPointBY
+
+namespace ColorPointBIntensity {
+static constexpr AttributeId Id = 0x0000003C;
+} // namespace ColorPointBIntensity
+
+namespace EnhancedCurrentHue {
+static constexpr AttributeId Id = 0x00004000;
+} // namespace EnhancedCurrentHue
+
+namespace EnhancedColorMode {
+static constexpr AttributeId Id = 0x00004001;
+} // namespace EnhancedColorMode
+
+namespace ColorLoopActive {
+static constexpr AttributeId Id = 0x00004002;
+} // namespace ColorLoopActive
+
+namespace ColorLoopDirection {
+static constexpr AttributeId Id = 0x00004003;
+} // namespace ColorLoopDirection
+
+namespace ColorLoopTime {
+static constexpr AttributeId Id = 0x00004004;
+} // namespace ColorLoopTime
+
+namespace ColorLoopStartEnhancedHue {
+static constexpr AttributeId Id = 0x00004005;
+} // namespace ColorLoopStartEnhancedHue
+
+namespace ColorLoopStoredEnhancedHue {
+static constexpr AttributeId Id = 0x00004006;
+} // namespace ColorLoopStoredEnhancedHue
+
+namespace ColorCapabilities {
+static constexpr AttributeId Id = 0x0000400A;
+} // namespace ColorCapabilities
+
+namespace ColorTempPhysicalMinMireds {
+static constexpr AttributeId Id = 0x0000400B;
+} // namespace ColorTempPhysicalMinMireds
+
+namespace ColorTempPhysicalMaxMireds {
+static constexpr AttributeId Id = 0x0000400C;
+} // namespace ColorTempPhysicalMaxMireds
+
+namespace CoupleColorTempToLevelMinMireds {
+static constexpr AttributeId Id = 0x0000400D;
+} // namespace CoupleColorTempToLevelMinMireds
+
+namespace StartUpColorTemperatureMireds {
+static constexpr AttributeId Id = 0x00004010;
+} // namespace StartUpColorTemperatureMireds
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ColorControl
+
+namespace BallastConfiguration {
+namespace Attributes {
+
+namespace PhysicalMinLevel {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PhysicalMinLevel
+
+namespace PhysicalMaxLevel {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace PhysicalMaxLevel
+
+namespace BallastStatus {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace BallastStatus
+
+namespace MinLevel {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace MinLevel
+
+namespace MaxLevel {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace MaxLevel
+
+namespace IntrinsicBallastFactor {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace IntrinsicBallastFactor
+
+namespace BallastFactorAdjustment {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace BallastFactorAdjustment
+
+namespace LampQuantity {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace LampQuantity
+
+namespace LampType {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace LampType
+
+namespace LampManufacturer {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace LampManufacturer
+
+namespace LampRatedHours {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace LampRatedHours
+
+namespace LampBurnHours {
+static constexpr AttributeId Id = 0x00000033;
+} // namespace LampBurnHours
+
+namespace LampAlarmMode {
+static constexpr AttributeId Id = 0x00000034;
+} // namespace LampAlarmMode
+
+namespace LampBurnHoursTripPoint {
+static constexpr AttributeId Id = 0x00000035;
+} // namespace LampBurnHoursTripPoint
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace BallastConfiguration
+
+namespace IlluminanceMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Tolerance
+
+namespace LightSensorType {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace LightSensorType
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace IlluminanceMeasurement
+
+namespace TemperatureMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Tolerance
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TemperatureMeasurement
+
+namespace PressureMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Tolerance
+
+namespace ScaledValue {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace ScaledValue
+
+namespace MinScaledValue {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace MinScaledValue
+
+namespace MaxScaledValue {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace MaxScaledValue
+
+namespace ScaledTolerance {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace ScaledTolerance
+
+namespace Scale {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace Scale
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace PressureMeasurement
+
+namespace FlowMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Tolerance
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FlowMeasurement
+
+namespace RelativeHumidityMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace Tolerance {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Tolerance
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RelativeHumidityMeasurement
+
+namespace OccupancySensing {
+namespace Attributes {
+
+namespace Occupancy {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Occupancy
+
+namespace OccupancySensorType {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace OccupancySensorType
+
+namespace OccupancySensorTypeBitmap {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace OccupancySensorTypeBitmap
+
+namespace HoldTime {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace HoldTime
+
+namespace HoldTimeLimits {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace HoldTimeLimits
+
+namespace PIROccupiedToUnoccupiedDelay {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace PIROccupiedToUnoccupiedDelay
+
+namespace PIRUnoccupiedToOccupiedDelay {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace PIRUnoccupiedToOccupiedDelay
+
+namespace PIRUnoccupiedToOccupiedThreshold {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace PIRUnoccupiedToOccupiedThreshold
+
+namespace UltrasonicOccupiedToUnoccupiedDelay {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace UltrasonicOccupiedToUnoccupiedDelay
+
+namespace UltrasonicUnoccupiedToOccupiedDelay {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace UltrasonicUnoccupiedToOccupiedDelay
+
+namespace UltrasonicUnoccupiedToOccupiedThreshold {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace UltrasonicUnoccupiedToOccupiedThreshold
+
+namespace PhysicalContactOccupiedToUnoccupiedDelay {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace PhysicalContactOccupiedToUnoccupiedDelay
+
+namespace PhysicalContactUnoccupiedToOccupiedDelay {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace PhysicalContactUnoccupiedToOccupiedDelay
+
+namespace PhysicalContactUnoccupiedToOccupiedThreshold {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace PhysicalContactUnoccupiedToOccupiedThreshold
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OccupancySensing
+
+namespace CarbonMonoxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CarbonMonoxideConcentrationMeasurement
+
+namespace CarbonDioxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CarbonDioxideConcentrationMeasurement
+
+namespace NitrogenDioxideConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace NitrogenDioxideConcentrationMeasurement
+
+namespace OzoneConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace OzoneConcentrationMeasurement
+
+namespace Pm25ConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm25ConcentrationMeasurement
+
+namespace FormaldehydeConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FormaldehydeConcentrationMeasurement
+
+namespace Pm1ConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm1ConcentrationMeasurement
+
+namespace Pm10ConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Pm10ConcentrationMeasurement
+
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+
+namespace RadonConcentrationMeasurement {
+namespace Attributes {
+
+namespace MeasuredValue {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MeasuredValue
+
+namespace MinMeasuredValue {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MinMeasuredValue
+
+namespace MaxMeasuredValue {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MaxMeasuredValue
+
+namespace PeakMeasuredValue {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace PeakMeasuredValue
+
+namespace PeakMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PeakMeasuredValueWindow
+
+namespace AverageMeasuredValue {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace AverageMeasuredValue
+
+namespace AverageMeasuredValueWindow {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace AverageMeasuredValueWindow
+
+namespace Uncertainty {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Uncertainty
+
+namespace MeasurementUnit {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace MeasurementUnit
+
+namespace MeasurementMedium {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace MeasurementMedium
+
+namespace LevelValue {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace LevelValue
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RadonConcentrationMeasurement
+
+namespace WiFiNetworkManagement {
+namespace Attributes {
+
+namespace Ssid {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Ssid
+
+namespace PassphraseSurrogate {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace PassphraseSurrogate
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WiFiNetworkManagement
+
+namespace ThreadBorderRouterManagement {
+namespace Attributes {
+
+namespace BorderRouterName {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace BorderRouterName
+
+namespace BorderAgentID {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace BorderAgentID
+
+namespace ThreadVersion {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ThreadVersion
+
+namespace InterfaceEnabled {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace InterfaceEnabled
+
+namespace ActiveDatasetTimestamp {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ActiveDatasetTimestamp
+
+namespace PendingDatasetTimestamp {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace PendingDatasetTimestamp
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadBorderRouterManagement
+
+namespace ThreadNetworkDirectory {
+namespace Attributes {
+
+namespace PreferredExtendedPanID {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace PreferredExtendedPanID
+
+namespace ThreadNetworks {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ThreadNetworks
+
+namespace ThreadNetworkTableSize {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ThreadNetworkTableSize
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ThreadNetworkDirectory
+
+namespace WakeOnLan {
+namespace Attributes {
+
+namespace MACAddress {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MACAddress
+
+namespace LinkLocalAddress {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace LinkLocalAddress
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WakeOnLan
+
+namespace Channel {
+namespace Attributes {
+
+namespace ChannelList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace ChannelList
+
+namespace Lineup {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Lineup
+
+namespace CurrentChannel {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace CurrentChannel
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Channel
+
+namespace TargetNavigator {
+namespace Attributes {
+
+namespace TargetList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace TargetList
+
+namespace CurrentTarget {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentTarget
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace TargetNavigator
+
+namespace MediaPlayback {
+namespace Attributes {
+
+namespace CurrentState {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CurrentState
+
+namespace StartTime {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace StartTime
+
+namespace Duration {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Duration
+
+namespace SampledPosition {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace SampledPosition
+
+namespace PlaybackSpeed {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace PlaybackSpeed
+
+namespace SeekRangeEnd {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace SeekRangeEnd
+
+namespace SeekRangeStart {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace SeekRangeStart
+
+namespace ActiveAudioTrack {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace ActiveAudioTrack
+
+namespace AvailableAudioTracks {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace AvailableAudioTracks
+
+namespace ActiveTextTrack {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace ActiveTextTrack
+
+namespace AvailableTextTracks {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace AvailableTextTracks
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MediaPlayback
+
+namespace MediaInput {
+namespace Attributes {
+
+namespace InputList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace InputList
+
+namespace CurrentInput {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentInput
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace MediaInput
+
+namespace LowPower {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace LowPower
+
+namespace KeypadInput {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace KeypadInput
+
+namespace ContentLauncher {
+namespace Attributes {
+
+namespace AcceptHeader {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace AcceptHeader
+
+namespace SupportedStreamingProtocols {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace SupportedStreamingProtocols
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentLauncher
+
+namespace AudioOutput {
+namespace Attributes {
+
+namespace OutputList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace OutputList
+
+namespace CurrentOutput {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentOutput
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AudioOutput
+
+namespace ApplicationLauncher {
+namespace Attributes {
+
+namespace CatalogList {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CatalogList
+
+namespace CurrentApp {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace CurrentApp
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ApplicationLauncher
+
+namespace ApplicationBasic {
+namespace Attributes {
+
+namespace VendorName {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace VendorName
+
+namespace VendorID {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace VendorID
+
+namespace ApplicationName {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace ApplicationName
+
+namespace ProductID {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ProductID
+
+namespace Application {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace Application
+
+namespace Status {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace Status
+
+namespace ApplicationVersion {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace ApplicationVersion
+
+namespace AllowedVendorList {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace AllowedVendorList
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ApplicationBasic
+
+namespace AccountLogin {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace AccountLogin
+
+namespace ContentControl {
+namespace Attributes {
+
+namespace Enabled {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Enabled
+
+namespace OnDemandRatings {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace OnDemandRatings
+
+namespace OnDemandRatingThreshold {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace OnDemandRatingThreshold
+
+namespace ScheduledContentRatings {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace ScheduledContentRatings
+
+namespace ScheduledContentRatingThreshold {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ScheduledContentRatingThreshold
+
+namespace ScreenDailyTime {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace ScreenDailyTime
+
+namespace RemainingScreenTime {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace RemainingScreenTime
+
+namespace BlockUnrated {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace BlockUnrated
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentControl
+
+namespace ContentAppObserver {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ContentAppObserver
+
+namespace ZoneManagement {
+namespace Attributes {
+
+namespace SupportedZoneSources {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedZoneSources
+
+namespace Zones {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Zones
+
+namespace Triggers {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Triggers
+
+namespace Sensitivity {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Sensitivity
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace ZoneManagement
+
+namespace CameraAvStreamManagement {
+namespace Attributes {
+
+namespace MaxConcurrentVideoEncoders {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MaxConcurrentVideoEncoders
+
+namespace MaxEncodedPixelRate {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MaxEncodedPixelRate
+
+namespace VideoSensorParams {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace VideoSensorParams
+
+namespace NightVisionCapable {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace NightVisionCapable
+
+namespace MinViewport {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace MinViewport
+
+namespace RateDistortionTradeOffPoints {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace RateDistortionTradeOffPoints
+
+namespace MaxContentBufferSize {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace MaxContentBufferSize
+
+namespace MicrophoneCapabilities {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace MicrophoneCapabilities
+
+namespace SpeakerCapabilities {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace SpeakerCapabilities
+
+namespace TwoWayTalkSupport {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace TwoWayTalkSupport
+
+namespace SupportedSnapshotParams {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace SupportedSnapshotParams
+
+namespace MaxNetworkBandwidth {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace MaxNetworkBandwidth
+
+namespace CurrentFrameRate {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace CurrentFrameRate
+
+namespace HDRModeEnabled {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace HDRModeEnabled
+
+namespace FabricsUsingCamera {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace FabricsUsingCamera
+
+namespace AllocatedVideoStreams {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace AllocatedVideoStreams
+
+namespace AllocatedAudioStreams {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace AllocatedAudioStreams
+
+namespace AllocatedSnapshotStreams {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace AllocatedSnapshotStreams
+
+namespace RankedVideoStreamPrioritiesList {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace RankedVideoStreamPrioritiesList
+
+namespace SoftRecordingPrivacyModeEnabled {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace SoftRecordingPrivacyModeEnabled
+
+namespace SoftLivestreamPrivacyModeEnabled {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace SoftLivestreamPrivacyModeEnabled
+
+namespace HardPrivacyModeOn {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace HardPrivacyModeOn
+
+namespace NightVision {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace NightVision
+
+namespace NightVisionIllum {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace NightVisionIllum
+
+namespace Viewport {
+static constexpr AttributeId Id = 0x00000018;
+} // namespace Viewport
+
+namespace SpeakerMuted {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace SpeakerMuted
+
+namespace SpeakerVolumeLevel {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace SpeakerVolumeLevel
+
+namespace SpeakerMaxLevel {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace SpeakerMaxLevel
+
+namespace SpeakerMinLevel {
+static constexpr AttributeId Id = 0x0000001C;
+} // namespace SpeakerMinLevel
+
+namespace MicrophoneMuted {
+static constexpr AttributeId Id = 0x0000001D;
+} // namespace MicrophoneMuted
+
+namespace MicrophoneVolumeLevel {
+static constexpr AttributeId Id = 0x0000001E;
+} // namespace MicrophoneVolumeLevel
+
+namespace MicrophoneMaxLevel {
+static constexpr AttributeId Id = 0x0000001F;
+} // namespace MicrophoneMaxLevel
+
+namespace MicrophoneMinLevel {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace MicrophoneMinLevel
+
+namespace MicrophoneAGCEnabled {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace MicrophoneAGCEnabled
+
+namespace ImageRotation {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace ImageRotation
+
+namespace ImageFlipHorizontal {
+static constexpr AttributeId Id = 0x00000023;
+} // namespace ImageFlipHorizontal
+
+namespace ImageFlipVertical {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace ImageFlipVertical
+
+namespace LocalVideoRecordingEnabled {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace LocalVideoRecordingEnabled
+
+namespace LocalSnapshotRecordingEnabled {
+static constexpr AttributeId Id = 0x00000026;
+} // namespace LocalSnapshotRecordingEnabled
+
+namespace StatusLightEnabled {
+static constexpr AttributeId Id = 0x00000027;
+} // namespace StatusLightEnabled
+
+namespace StatusLightBrightness {
+static constexpr AttributeId Id = 0x00000028;
+} // namespace StatusLightBrightness
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CameraAvStreamManagement
+
+namespace CameraAvSettingsUserLevelManagement {
+namespace Attributes {
+
+namespace MPTZPosition {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace MPTZPosition
+
+namespace MaxPresets {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace MaxPresets
+
+namespace MPTZPresets {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace MPTZPresets
+
+namespace DPTZRelativeMove {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace DPTZRelativeMove
+
+namespace ZoomMax {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace ZoomMax
+
+namespace TiltMin {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace TiltMin
+
+namespace TiltMax {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace TiltMax
+
+namespace PanMin {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace PanMin
+
+namespace PanMax {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace PanMax
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CameraAvSettingsUserLevelManagement
+
+namespace WebRTCTransportProvider {
+namespace Attributes {
+
+namespace CurrentSessions {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CurrentSessions
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WebRTCTransportProvider
+
+namespace WebRTCTransportRequestor {
+namespace Attributes {
+
+namespace CurrentSessions {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace CurrentSessions
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace WebRTCTransportRequestor
+
+namespace Chime {
+namespace Attributes {
+
+namespace InstalledChimeSounds {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace InstalledChimeSounds
+
+namespace ActiveChimeID {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace ActiveChimeID
+
+namespace Enabled {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Enabled
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace Chime
+
+namespace EcosystemInformation {
+namespace Attributes {
+
+namespace DeviceDirectory {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace DeviceDirectory
+
+namespace LocationDirectory {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace LocationDirectory
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace EcosystemInformation
+
+namespace CommissionerControl {
+namespace Attributes {
+
+namespace SupportedDeviceCategories {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace SupportedDeviceCategories
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace CommissionerControl
+
+namespace UnitTesting {
+namespace Attributes {
+
+namespace Boolean {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Boolean
+
+namespace Bitmap8 {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Bitmap8
+
+namespace Bitmap16 {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace Bitmap16
+
+namespace Bitmap32 {
+static constexpr AttributeId Id = 0x00000003;
+} // namespace Bitmap32
+
+namespace Bitmap64 {
+static constexpr AttributeId Id = 0x00000004;
+} // namespace Bitmap64
+
+namespace Int8u {
+static constexpr AttributeId Id = 0x00000005;
+} // namespace Int8u
+
+namespace Int16u {
+static constexpr AttributeId Id = 0x00000006;
+} // namespace Int16u
+
+namespace Int24u {
+static constexpr AttributeId Id = 0x00000007;
+} // namespace Int24u
+
+namespace Int32u {
+static constexpr AttributeId Id = 0x00000008;
+} // namespace Int32u
+
+namespace Int40u {
+static constexpr AttributeId Id = 0x00000009;
+} // namespace Int40u
+
+namespace Int48u {
+static constexpr AttributeId Id = 0x0000000A;
+} // namespace Int48u
+
+namespace Int56u {
+static constexpr AttributeId Id = 0x0000000B;
+} // namespace Int56u
+
+namespace Int64u {
+static constexpr AttributeId Id = 0x0000000C;
+} // namespace Int64u
+
+namespace Int8s {
+static constexpr AttributeId Id = 0x0000000D;
+} // namespace Int8s
+
+namespace Int16s {
+static constexpr AttributeId Id = 0x0000000E;
+} // namespace Int16s
+
+namespace Int24s {
+static constexpr AttributeId Id = 0x0000000F;
+} // namespace Int24s
+
+namespace Int32s {
+static constexpr AttributeId Id = 0x00000010;
+} // namespace Int32s
+
+namespace Int40s {
+static constexpr AttributeId Id = 0x00000011;
+} // namespace Int40s
+
+namespace Int48s {
+static constexpr AttributeId Id = 0x00000012;
+} // namespace Int48s
+
+namespace Int56s {
+static constexpr AttributeId Id = 0x00000013;
+} // namespace Int56s
+
+namespace Int64s {
+static constexpr AttributeId Id = 0x00000014;
+} // namespace Int64s
+
+namespace Enum8 {
+static constexpr AttributeId Id = 0x00000015;
+} // namespace Enum8
+
+namespace Enum16 {
+static constexpr AttributeId Id = 0x00000016;
+} // namespace Enum16
+
+namespace FloatSingle {
+static constexpr AttributeId Id = 0x00000017;
+} // namespace FloatSingle
+
+namespace FloatDouble {
+static constexpr AttributeId Id = 0x00000018;
+} // namespace FloatDouble
+
+namespace OctetString {
+static constexpr AttributeId Id = 0x00000019;
+} // namespace OctetString
+
+namespace ListInt8u {
+static constexpr AttributeId Id = 0x0000001A;
+} // namespace ListInt8u
+
+namespace ListOctetString {
+static constexpr AttributeId Id = 0x0000001B;
+} // namespace ListOctetString
+
+namespace ListStructOctetString {
+static constexpr AttributeId Id = 0x0000001C;
+} // namespace ListStructOctetString
+
+namespace LongOctetString {
+static constexpr AttributeId Id = 0x0000001D;
+} // namespace LongOctetString
+
+namespace CharString {
+static constexpr AttributeId Id = 0x0000001E;
+} // namespace CharString
+
+namespace LongCharString {
+static constexpr AttributeId Id = 0x0000001F;
+} // namespace LongCharString
+
+namespace EpochUs {
+static constexpr AttributeId Id = 0x00000020;
+} // namespace EpochUs
+
+namespace EpochS {
+static constexpr AttributeId Id = 0x00000021;
+} // namespace EpochS
+
+namespace VendorId {
+static constexpr AttributeId Id = 0x00000022;
+} // namespace VendorId
+
+namespace ListNullablesAndOptionalsStruct {
+static constexpr AttributeId Id = 0x00000023;
+} // namespace ListNullablesAndOptionalsStruct
+
+namespace EnumAttr {
+static constexpr AttributeId Id = 0x00000024;
+} // namespace EnumAttr
+
+namespace StructAttr {
+static constexpr AttributeId Id = 0x00000025;
+} // namespace StructAttr
+
+namespace RangeRestrictedInt8u {
+static constexpr AttributeId Id = 0x00000026;
+} // namespace RangeRestrictedInt8u
+
+namespace RangeRestrictedInt8s {
+static constexpr AttributeId Id = 0x00000027;
+} // namespace RangeRestrictedInt8s
+
+namespace RangeRestrictedInt16u {
+static constexpr AttributeId Id = 0x00000028;
+} // namespace RangeRestrictedInt16u
+
+namespace RangeRestrictedInt16s {
+static constexpr AttributeId Id = 0x00000029;
+} // namespace RangeRestrictedInt16s
+
+namespace ListLongOctetString {
+static constexpr AttributeId Id = 0x0000002A;
+} // namespace ListLongOctetString
+
+namespace ListFabricScoped {
+static constexpr AttributeId Id = 0x0000002B;
+} // namespace ListFabricScoped
+
+namespace TimedWriteBoolean {
+static constexpr AttributeId Id = 0x00000030;
+} // namespace TimedWriteBoolean
+
+namespace GeneralErrorBoolean {
+static constexpr AttributeId Id = 0x00000031;
+} // namespace GeneralErrorBoolean
+
+namespace ClusterErrorBoolean {
+static constexpr AttributeId Id = 0x00000032;
+} // namespace ClusterErrorBoolean
+
+namespace GlobalEnum {
+static constexpr AttributeId Id = 0x00000033;
+} // namespace GlobalEnum
+
+namespace GlobalStruct {
+static constexpr AttributeId Id = 0x00000034;
+} // namespace GlobalStruct
+
+namespace Unsupported {
+static constexpr AttributeId Id = 0x000000FF;
+} // namespace Unsupported
+
+namespace ReadFailureCode {
+static constexpr AttributeId Id = 0x00003000;
+} // namespace ReadFailureCode
+
+namespace FailureInt32U {
+static constexpr AttributeId Id = 0x00003001;
+} // namespace FailureInt32U
+
+namespace NullableBoolean {
+static constexpr AttributeId Id = 0x00004000;
+} // namespace NullableBoolean
+
+namespace NullableBitmap8 {
+static constexpr AttributeId Id = 0x00004001;
+} // namespace NullableBitmap8
+
+namespace NullableBitmap16 {
+static constexpr AttributeId Id = 0x00004002;
+} // namespace NullableBitmap16
+
+namespace NullableBitmap32 {
+static constexpr AttributeId Id = 0x00004003;
+} // namespace NullableBitmap32
+
+namespace NullableBitmap64 {
+static constexpr AttributeId Id = 0x00004004;
+} // namespace NullableBitmap64
+
+namespace NullableInt8u {
+static constexpr AttributeId Id = 0x00004005;
+} // namespace NullableInt8u
+
+namespace NullableInt16u {
+static constexpr AttributeId Id = 0x00004006;
+} // namespace NullableInt16u
+
+namespace NullableInt24u {
+static constexpr AttributeId Id = 0x00004007;
+} // namespace NullableInt24u
+
+namespace NullableInt32u {
+static constexpr AttributeId Id = 0x00004008;
+} // namespace NullableInt32u
+
+namespace NullableInt40u {
+static constexpr AttributeId Id = 0x00004009;
+} // namespace NullableInt40u
+
+namespace NullableInt48u {
+static constexpr AttributeId Id = 0x0000400A;
+} // namespace NullableInt48u
+
+namespace NullableInt56u {
+static constexpr AttributeId Id = 0x0000400B;
+} // namespace NullableInt56u
+
+namespace NullableInt64u {
+static constexpr AttributeId Id = 0x0000400C;
+} // namespace NullableInt64u
+
+namespace NullableInt8s {
+static constexpr AttributeId Id = 0x0000400D;
+} // namespace NullableInt8s
+
+namespace NullableInt16s {
+static constexpr AttributeId Id = 0x0000400E;
+} // namespace NullableInt16s
+
+namespace NullableInt24s {
+static constexpr AttributeId Id = 0x0000400F;
+} // namespace NullableInt24s
+
+namespace NullableInt32s {
+static constexpr AttributeId Id = 0x00004010;
+} // namespace NullableInt32s
+
+namespace NullableInt40s {
+static constexpr AttributeId Id = 0x00004011;
+} // namespace NullableInt40s
+
+namespace NullableInt48s {
+static constexpr AttributeId Id = 0x00004012;
+} // namespace NullableInt48s
+
+namespace NullableInt56s {
+static constexpr AttributeId Id = 0x00004013;
+} // namespace NullableInt56s
+
+namespace NullableInt64s {
+static constexpr AttributeId Id = 0x00004014;
+} // namespace NullableInt64s
+
+namespace NullableEnum8 {
+static constexpr AttributeId Id = 0x00004015;
+} // namespace NullableEnum8
+
+namespace NullableEnum16 {
+static constexpr AttributeId Id = 0x00004016;
+} // namespace NullableEnum16
+
+namespace NullableFloatSingle {
+static constexpr AttributeId Id = 0x00004017;
+} // namespace NullableFloatSingle
+
+namespace NullableFloatDouble {
+static constexpr AttributeId Id = 0x00004018;
+} // namespace NullableFloatDouble
+
+namespace NullableOctetString {
+static constexpr AttributeId Id = 0x00004019;
+} // namespace NullableOctetString
+
+namespace NullableCharString {
+static constexpr AttributeId Id = 0x0000401E;
+} // namespace NullableCharString
+
+namespace NullableEnumAttr {
+static constexpr AttributeId Id = 0x00004024;
+} // namespace NullableEnumAttr
+
+namespace NullableStruct {
+static constexpr AttributeId Id = 0x00004025;
+} // namespace NullableStruct
+
+namespace NullableRangeRestrictedInt8u {
+static constexpr AttributeId Id = 0x00004026;
+} // namespace NullableRangeRestrictedInt8u
+
+namespace NullableRangeRestrictedInt8s {
+static constexpr AttributeId Id = 0x00004027;
+} // namespace NullableRangeRestrictedInt8s
+
+namespace NullableRangeRestrictedInt16u {
+static constexpr AttributeId Id = 0x00004028;
+} // namespace NullableRangeRestrictedInt16u
+
+namespace NullableRangeRestrictedInt16s {
+static constexpr AttributeId Id = 0x00004029;
+} // namespace NullableRangeRestrictedInt16s
+
+namespace WriteOnlyInt8u {
+static constexpr AttributeId Id = 0x0000402A;
+} // namespace WriteOnlyInt8u
+
+namespace NullableGlobalEnum {
+static constexpr AttributeId Id = 0x00004033;
+} // namespace NullableGlobalEnum
+
+namespace NullableGlobalStruct {
+static constexpr AttributeId Id = 0x00004034;
+} // namespace NullableGlobalStruct
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+namespace MeiInt8u {
+static constexpr AttributeId Id = 0xFFF24F01;
+} // namespace MeiInt8u
+
+} // namespace Attributes
+} // namespace UnitTesting
+
+namespace FaultInjection {
+namespace Attributes {
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace FaultInjection
+
+namespace SampleManufacturerSpecific {
+namespace Attributes {
+
+namespace FlipFlop {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace FlipFlop
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SampleManufacturerSpecific
+
+namespace SampleExternalManufacturerSpecific {
+namespace Attributes {
+
+namespace FlipFlop {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace FlipFlop
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
new file mode 100644
index 00000000000000..a090f3870f495a
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
@@ -0,0 +1,418 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <app/util/basic-types.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace Identify {
+static constexpr ClusterId Id = 0x00000003;
+} // namespace Identify
+namespace Groups {
+static constexpr ClusterId Id = 0x00000004;
+} // namespace Groups
+namespace OnOff {
+static constexpr ClusterId Id = 0x00000006;
+} // namespace OnOff
+namespace LevelControl {
+static constexpr ClusterId Id = 0x00000008;
+} // namespace LevelControl
+namespace PulseWidthModulation {
+static constexpr ClusterId Id = 0x0000001C;
+} // namespace PulseWidthModulation
+namespace Descriptor {
+static constexpr ClusterId Id = 0x0000001D;
+} // namespace Descriptor
+namespace Binding {
+static constexpr ClusterId Id = 0x0000001E;
+} // namespace Binding
+namespace AccessControl {
+static constexpr ClusterId Id = 0x0000001F;
+} // namespace AccessControl
+namespace Actions {
+static constexpr ClusterId Id = 0x00000025;
+} // namespace Actions
+namespace BasicInformation {
+static constexpr ClusterId Id = 0x00000028;
+} // namespace BasicInformation
+namespace OtaSoftwareUpdateProvider {
+static constexpr ClusterId Id = 0x00000029;
+} // namespace OtaSoftwareUpdateProvider
+namespace OtaSoftwareUpdateRequestor {
+static constexpr ClusterId Id = 0x0000002A;
+} // namespace OtaSoftwareUpdateRequestor
+namespace LocalizationConfiguration {
+static constexpr ClusterId Id = 0x0000002B;
+} // namespace LocalizationConfiguration
+namespace TimeFormatLocalization {
+static constexpr ClusterId Id = 0x0000002C;
+} // namespace TimeFormatLocalization
+namespace UnitLocalization {
+static constexpr ClusterId Id = 0x0000002D;
+} // namespace UnitLocalization
+namespace PowerSourceConfiguration {
+static constexpr ClusterId Id = 0x0000002E;
+} // namespace PowerSourceConfiguration
+namespace PowerSource {
+static constexpr ClusterId Id = 0x0000002F;
+} // namespace PowerSource
+namespace GeneralCommissioning {
+static constexpr ClusterId Id = 0x00000030;
+} // namespace GeneralCommissioning
+namespace NetworkCommissioning {
+static constexpr ClusterId Id = 0x00000031;
+} // namespace NetworkCommissioning
+namespace DiagnosticLogs {
+static constexpr ClusterId Id = 0x00000032;
+} // namespace DiagnosticLogs
+namespace GeneralDiagnostics {
+static constexpr ClusterId Id = 0x00000033;
+} // namespace GeneralDiagnostics
+namespace SoftwareDiagnostics {
+static constexpr ClusterId Id = 0x00000034;
+} // namespace SoftwareDiagnostics
+namespace ThreadNetworkDiagnostics {
+static constexpr ClusterId Id = 0x00000035;
+} // namespace ThreadNetworkDiagnostics
+namespace WiFiNetworkDiagnostics {
+static constexpr ClusterId Id = 0x00000036;
+} // namespace WiFiNetworkDiagnostics
+namespace EthernetNetworkDiagnostics {
+static constexpr ClusterId Id = 0x00000037;
+} // namespace EthernetNetworkDiagnostics
+namespace TimeSynchronization {
+static constexpr ClusterId Id = 0x00000038;
+} // namespace TimeSynchronization
+namespace BridgedDeviceBasicInformation {
+static constexpr ClusterId Id = 0x00000039;
+} // namespace BridgedDeviceBasicInformation
+namespace Switch {
+static constexpr ClusterId Id = 0x0000003B;
+} // namespace Switch
+namespace AdministratorCommissioning {
+static constexpr ClusterId Id = 0x0000003C;
+} // namespace AdministratorCommissioning
+namespace OperationalCredentials {
+static constexpr ClusterId Id = 0x0000003E;
+} // namespace OperationalCredentials
+namespace GroupKeyManagement {
+static constexpr ClusterId Id = 0x0000003F;
+} // namespace GroupKeyManagement
+namespace FixedLabel {
+static constexpr ClusterId Id = 0x00000040;
+} // namespace FixedLabel
+namespace UserLabel {
+static constexpr ClusterId Id = 0x00000041;
+} // namespace UserLabel
+namespace ProxyConfiguration {
+static constexpr ClusterId Id = 0x00000042;
+} // namespace ProxyConfiguration
+namespace ProxyDiscovery {
+static constexpr ClusterId Id = 0x00000043;
+} // namespace ProxyDiscovery
+namespace ProxyValid {
+static constexpr ClusterId Id = 0x00000044;
+} // namespace ProxyValid
+namespace BooleanState {
+static constexpr ClusterId Id = 0x00000045;
+} // namespace BooleanState
+namespace IcdManagement {
+static constexpr ClusterId Id = 0x00000046;
+} // namespace IcdManagement
+namespace Timer {
+static constexpr ClusterId Id = 0x00000047;
+} // namespace Timer
+namespace OvenCavityOperationalState {
+static constexpr ClusterId Id = 0x00000048;
+} // namespace OvenCavityOperationalState
+namespace OvenMode {
+static constexpr ClusterId Id = 0x00000049;
+} // namespace OvenMode
+namespace LaundryDryerControls {
+static constexpr ClusterId Id = 0x0000004A;
+} // namespace LaundryDryerControls
+namespace ModeSelect {
+static constexpr ClusterId Id = 0x00000050;
+} // namespace ModeSelect
+namespace LaundryWasherMode {
+static constexpr ClusterId Id = 0x00000051;
+} // namespace LaundryWasherMode
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+static constexpr ClusterId Id = 0x00000052;
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+namespace LaundryWasherControls {
+static constexpr ClusterId Id = 0x00000053;
+} // namespace LaundryWasherControls
+namespace RvcRunMode {
+static constexpr ClusterId Id = 0x00000054;
+} // namespace RvcRunMode
+namespace RvcCleanMode {
+static constexpr ClusterId Id = 0x00000055;
+} // namespace RvcCleanMode
+namespace TemperatureControl {
+static constexpr ClusterId Id = 0x00000056;
+} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+static constexpr ClusterId Id = 0x00000057;
+} // namespace RefrigeratorAlarm
+namespace DishwasherMode {
+static constexpr ClusterId Id = 0x00000059;
+} // namespace DishwasherMode
+namespace AirQuality {
+static constexpr ClusterId Id = 0x0000005B;
+} // namespace AirQuality
+namespace SmokeCoAlarm {
+static constexpr ClusterId Id = 0x0000005C;
+} // namespace SmokeCoAlarm
+namespace DishwasherAlarm {
+static constexpr ClusterId Id = 0x0000005D;
+} // namespace DishwasherAlarm
+namespace MicrowaveOvenMode {
+static constexpr ClusterId Id = 0x0000005E;
+} // namespace MicrowaveOvenMode
+namespace MicrowaveOvenControl {
+static constexpr ClusterId Id = 0x0000005F;
+} // namespace MicrowaveOvenControl
+namespace OperationalState {
+static constexpr ClusterId Id = 0x00000060;
+} // namespace OperationalState
+namespace RvcOperationalState {
+static constexpr ClusterId Id = 0x00000061;
+} // namespace RvcOperationalState
+namespace ScenesManagement {
+static constexpr ClusterId Id = 0x00000062;
+} // namespace ScenesManagement
+namespace HepaFilterMonitoring {
+static constexpr ClusterId Id = 0x00000071;
+} // namespace HepaFilterMonitoring
+namespace ActivatedCarbonFilterMonitoring {
+static constexpr ClusterId Id = 0x00000072;
+} // namespace ActivatedCarbonFilterMonitoring
+namespace BooleanStateConfiguration {
+static constexpr ClusterId Id = 0x00000080;
+} // namespace BooleanStateConfiguration
+namespace ValveConfigurationAndControl {
+static constexpr ClusterId Id = 0x00000081;
+} // namespace ValveConfigurationAndControl
+namespace ElectricalPowerMeasurement {
+static constexpr ClusterId Id = 0x00000090;
+} // namespace ElectricalPowerMeasurement
+namespace ElectricalEnergyMeasurement {
+static constexpr ClusterId Id = 0x00000091;
+} // namespace ElectricalEnergyMeasurement
+namespace WaterHeaterManagement {
+static constexpr ClusterId Id = 0x00000094;
+} // namespace WaterHeaterManagement
+namespace DemandResponseLoadControl {
+static constexpr ClusterId Id = 0x00000096;
+} // namespace DemandResponseLoadControl
+namespace Messages {
+static constexpr ClusterId Id = 0x00000097;
+} // namespace Messages
+namespace DeviceEnergyManagement {
+static constexpr ClusterId Id = 0x00000098;
+} // namespace DeviceEnergyManagement
+namespace EnergyEvse {
+static constexpr ClusterId Id = 0x00000099;
+} // namespace EnergyEvse
+namespace EnergyPreference {
+static constexpr ClusterId Id = 0x0000009B;
+} // namespace EnergyPreference
+namespace PowerTopology {
+static constexpr ClusterId Id = 0x0000009C;
+} // namespace PowerTopology
+namespace EnergyEvseMode {
+static constexpr ClusterId Id = 0x0000009D;
+} // namespace EnergyEvseMode
+namespace WaterHeaterMode {
+static constexpr ClusterId Id = 0x0000009E;
+} // namespace WaterHeaterMode
+namespace DeviceEnergyManagementMode {
+static constexpr ClusterId Id = 0x0000009F;
+} // namespace DeviceEnergyManagementMode
+namespace DoorLock {
+static constexpr ClusterId Id = 0x00000101;
+} // namespace DoorLock
+namespace WindowCovering {
+static constexpr ClusterId Id = 0x00000102;
+} // namespace WindowCovering
+namespace ServiceArea {
+static constexpr ClusterId Id = 0x00000150;
+} // namespace ServiceArea
+namespace PumpConfigurationAndControl {
+static constexpr ClusterId Id = 0x00000200;
+} // namespace PumpConfigurationAndControl
+namespace Thermostat {
+static constexpr ClusterId Id = 0x00000201;
+} // namespace Thermostat
+namespace FanControl {
+static constexpr ClusterId Id = 0x00000202;
+} // namespace FanControl
+namespace ThermostatUserInterfaceConfiguration {
+static constexpr ClusterId Id = 0x00000204;
+} // namespace ThermostatUserInterfaceConfiguration
+namespace ColorControl {
+static constexpr ClusterId Id = 0x00000300;
+} // namespace ColorControl
+namespace BallastConfiguration {
+static constexpr ClusterId Id = 0x00000301;
+} // namespace BallastConfiguration
+namespace IlluminanceMeasurement {
+static constexpr ClusterId Id = 0x00000400;
+} // namespace IlluminanceMeasurement
+namespace TemperatureMeasurement {
+static constexpr ClusterId Id = 0x00000402;
+} // namespace TemperatureMeasurement
+namespace PressureMeasurement {
+static constexpr ClusterId Id = 0x00000403;
+} // namespace PressureMeasurement
+namespace FlowMeasurement {
+static constexpr ClusterId Id = 0x00000404;
+} // namespace FlowMeasurement
+namespace RelativeHumidityMeasurement {
+static constexpr ClusterId Id = 0x00000405;
+} // namespace RelativeHumidityMeasurement
+namespace OccupancySensing {
+static constexpr ClusterId Id = 0x00000406;
+} // namespace OccupancySensing
+namespace CarbonMonoxideConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000040C;
+} // namespace CarbonMonoxideConcentrationMeasurement
+namespace CarbonDioxideConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000040D;
+} // namespace CarbonDioxideConcentrationMeasurement
+namespace NitrogenDioxideConcentrationMeasurement {
+static constexpr ClusterId Id = 0x00000413;
+} // namespace NitrogenDioxideConcentrationMeasurement
+namespace OzoneConcentrationMeasurement {
+static constexpr ClusterId Id = 0x00000415;
+} // namespace OzoneConcentrationMeasurement
+namespace Pm25ConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000042A;
+} // namespace Pm25ConcentrationMeasurement
+namespace FormaldehydeConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000042B;
+} // namespace FormaldehydeConcentrationMeasurement
+namespace Pm1ConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000042C;
+} // namespace Pm1ConcentrationMeasurement
+namespace Pm10ConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000042D;
+} // namespace Pm10ConcentrationMeasurement
+namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000042E;
+} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
+namespace RadonConcentrationMeasurement {
+static constexpr ClusterId Id = 0x0000042F;
+} // namespace RadonConcentrationMeasurement
+namespace WiFiNetworkManagement {
+static constexpr ClusterId Id = 0x00000451;
+} // namespace WiFiNetworkManagement
+namespace ThreadBorderRouterManagement {
+static constexpr ClusterId Id = 0x00000452;
+} // namespace ThreadBorderRouterManagement
+namespace ThreadNetworkDirectory {
+static constexpr ClusterId Id = 0x00000453;
+} // namespace ThreadNetworkDirectory
+namespace WakeOnLan {
+static constexpr ClusterId Id = 0x00000503;
+} // namespace WakeOnLan
+namespace Channel {
+static constexpr ClusterId Id = 0x00000504;
+} // namespace Channel
+namespace TargetNavigator {
+static constexpr ClusterId Id = 0x00000505;
+} // namespace TargetNavigator
+namespace MediaPlayback {
+static constexpr ClusterId Id = 0x00000506;
+} // namespace MediaPlayback
+namespace MediaInput {
+static constexpr ClusterId Id = 0x00000507;
+} // namespace MediaInput
+namespace LowPower {
+static constexpr ClusterId Id = 0x00000508;
+} // namespace LowPower
+namespace KeypadInput {
+static constexpr ClusterId Id = 0x00000509;
+} // namespace KeypadInput
+namespace ContentLauncher {
+static constexpr ClusterId Id = 0x0000050A;
+} // namespace ContentLauncher
+namespace AudioOutput {
+static constexpr ClusterId Id = 0x0000050B;
+} // namespace AudioOutput
+namespace ApplicationLauncher {
+static constexpr ClusterId Id = 0x0000050C;
+} // namespace ApplicationLauncher
+namespace ApplicationBasic {
+static constexpr ClusterId Id = 0x0000050D;
+} // namespace ApplicationBasic
+namespace AccountLogin {
+static constexpr ClusterId Id = 0x0000050E;
+} // namespace AccountLogin
+namespace ContentControl {
+static constexpr ClusterId Id = 0x0000050F;
+} // namespace ContentControl
+namespace ContentAppObserver {
+static constexpr ClusterId Id = 0x00000510;
+} // namespace ContentAppObserver
+namespace ZoneManagement {
+static constexpr ClusterId Id = 0x00000550;
+} // namespace ZoneManagement
+namespace CameraAvStreamManagement {
+static constexpr ClusterId Id = 0x00000551;
+} // namespace CameraAvStreamManagement
+namespace CameraAvSettingsUserLevelManagement {
+static constexpr ClusterId Id = 0x00000552;
+} // namespace CameraAvSettingsUserLevelManagement
+namespace WebRTCTransportProvider {
+static constexpr ClusterId Id = 0x00000553;
+} // namespace WebRTCTransportProvider
+namespace WebRTCTransportRequestor {
+static constexpr ClusterId Id = 0x00000554;
+} // namespace WebRTCTransportRequestor
+namespace Chime {
+static constexpr ClusterId Id = 0x00000556;
+} // namespace Chime
+namespace EcosystemInformation {
+static constexpr ClusterId Id = 0x00000750;
+} // namespace EcosystemInformation
+namespace CommissionerControl {
+static constexpr ClusterId Id = 0x00000751;
+} // namespace CommissionerControl
+namespace UnitTesting {
+static constexpr ClusterId Id = 0xFFF1FC05;
+} // namespace UnitTesting
+namespace FaultInjection {
+static constexpr ClusterId Id = 0xFFF1FC06;
+} // namespace FaultInjection
+namespace SampleManufacturerSpecific {
+static constexpr ClusterId Id = 0xFFF1FC20;
+} // namespace SampleManufacturerSpecific
+namespace SampleExternalManufacturerSpecific {
+static constexpr ClusterId Id = 0xFFF1FC21;
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
new file mode 100644
index 00000000000000..e162eb35bf5de8
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
@@ -0,0 +1,2242 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <app/util/basic-types.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+// Matter does not have global commands
+
+namespace Identify {
+namespace Commands {
+
+namespace Identify {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Identify
+
+namespace TriggerEffect {
+static constexpr CommandId Id = 0x00000040;
+} // namespace TriggerEffect
+
+} // namespace Commands
+} // namespace Identify
+
+namespace Groups {
+namespace Commands {
+
+namespace AddGroup {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AddGroup
+
+namespace AddGroupResponse {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AddGroupResponse
+
+namespace ViewGroup {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ViewGroup
+
+namespace ViewGroupResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ViewGroupResponse
+
+namespace GetGroupMembership {
+static constexpr CommandId Id = 0x00000002;
+} // namespace GetGroupMembership
+
+namespace GetGroupMembershipResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace GetGroupMembershipResponse
+
+namespace RemoveGroup {
+static constexpr CommandId Id = 0x00000003;
+} // namespace RemoveGroup
+
+namespace RemoveGroupResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace RemoveGroupResponse
+
+namespace RemoveAllGroups {
+static constexpr CommandId Id = 0x00000004;
+} // namespace RemoveAllGroups
+
+namespace AddGroupIfIdentifying {
+static constexpr CommandId Id = 0x00000005;
+} // namespace AddGroupIfIdentifying
+
+} // namespace Commands
+} // namespace Groups
+
+namespace OnOff {
+namespace Commands {
+
+namespace Off {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Off
+
+namespace On {
+static constexpr CommandId Id = 0x00000001;
+} // namespace On
+
+namespace Toggle {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Toggle
+
+namespace OffWithEffect {
+static constexpr CommandId Id = 0x00000040;
+} // namespace OffWithEffect
+
+namespace OnWithRecallGlobalScene {
+static constexpr CommandId Id = 0x00000041;
+} // namespace OnWithRecallGlobalScene
+
+namespace OnWithTimedOff {
+static constexpr CommandId Id = 0x00000042;
+} // namespace OnWithTimedOff
+
+} // namespace Commands
+} // namespace OnOff
+
+namespace LevelControl {
+namespace Commands {
+
+namespace MoveToLevel {
+static constexpr CommandId Id = 0x00000000;
+} // namespace MoveToLevel
+
+namespace Move {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Move
+
+namespace Step {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Step
+
+namespace Stop {
+static constexpr CommandId Id = 0x00000003;
+} // namespace Stop
+
+namespace MoveToLevelWithOnOff {
+static constexpr CommandId Id = 0x00000004;
+} // namespace MoveToLevelWithOnOff
+
+namespace MoveWithOnOff {
+static constexpr CommandId Id = 0x00000005;
+} // namespace MoveWithOnOff
+
+namespace StepWithOnOff {
+static constexpr CommandId Id = 0x00000006;
+} // namespace StepWithOnOff
+
+namespace StopWithOnOff {
+static constexpr CommandId Id = 0x00000007;
+} // namespace StopWithOnOff
+
+namespace MoveToClosestFrequency {
+static constexpr CommandId Id = 0x00000008;
+} // namespace MoveToClosestFrequency
+
+} // namespace Commands
+} // namespace LevelControl
+
+namespace AccessControl {
+namespace Commands {
+
+namespace ReviewFabricRestrictions {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ReviewFabricRestrictions
+
+namespace ReviewFabricRestrictionsResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ReviewFabricRestrictionsResponse
+
+} // namespace Commands
+} // namespace AccessControl
+
+namespace Actions {
+namespace Commands {
+
+namespace InstantAction {
+static constexpr CommandId Id = 0x00000000;
+} // namespace InstantAction
+
+namespace InstantActionWithTransition {
+static constexpr CommandId Id = 0x00000001;
+} // namespace InstantActionWithTransition
+
+namespace StartAction {
+static constexpr CommandId Id = 0x00000002;
+} // namespace StartAction
+
+namespace StartActionWithDuration {
+static constexpr CommandId Id = 0x00000003;
+} // namespace StartActionWithDuration
+
+namespace StopAction {
+static constexpr CommandId Id = 0x00000004;
+} // namespace StopAction
+
+namespace PauseAction {
+static constexpr CommandId Id = 0x00000005;
+} // namespace PauseAction
+
+namespace PauseActionWithDuration {
+static constexpr CommandId Id = 0x00000006;
+} // namespace PauseActionWithDuration
+
+namespace ResumeAction {
+static constexpr CommandId Id = 0x00000007;
+} // namespace ResumeAction
+
+namespace EnableAction {
+static constexpr CommandId Id = 0x00000008;
+} // namespace EnableAction
+
+namespace EnableActionWithDuration {
+static constexpr CommandId Id = 0x00000009;
+} // namespace EnableActionWithDuration
+
+namespace DisableAction {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace DisableAction
+
+namespace DisableActionWithDuration {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace DisableActionWithDuration
+
+} // namespace Commands
+} // namespace Actions
+
+namespace BasicInformation {
+namespace Commands {
+
+namespace MfgSpecificPing {
+static constexpr CommandId Id = 0x10020000;
+} // namespace MfgSpecificPing
+
+} // namespace Commands
+} // namespace BasicInformation
+
+namespace OtaSoftwareUpdateProvider {
+namespace Commands {
+
+namespace QueryImage {
+static constexpr CommandId Id = 0x00000000;
+} // namespace QueryImage
+
+namespace QueryImageResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace QueryImageResponse
+
+namespace ApplyUpdateRequest {
+static constexpr CommandId Id = 0x00000002;
+} // namespace ApplyUpdateRequest
+
+namespace ApplyUpdateResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace ApplyUpdateResponse
+
+namespace NotifyUpdateApplied {
+static constexpr CommandId Id = 0x00000004;
+} // namespace NotifyUpdateApplied
+
+} // namespace Commands
+} // namespace OtaSoftwareUpdateProvider
+
+namespace OtaSoftwareUpdateRequestor {
+namespace Commands {
+
+namespace AnnounceOTAProvider {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AnnounceOTAProvider
+
+} // namespace Commands
+} // namespace OtaSoftwareUpdateRequestor
+
+namespace GeneralCommissioning {
+namespace Commands {
+
+namespace ArmFailSafe {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ArmFailSafe
+
+namespace ArmFailSafeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ArmFailSafeResponse
+
+namespace SetRegulatoryConfig {
+static constexpr CommandId Id = 0x00000002;
+} // namespace SetRegulatoryConfig
+
+namespace SetRegulatoryConfigResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace SetRegulatoryConfigResponse
+
+namespace CommissioningComplete {
+static constexpr CommandId Id = 0x00000004;
+} // namespace CommissioningComplete
+
+namespace CommissioningCompleteResponse {
+static constexpr CommandId Id = 0x00000005;
+} // namespace CommissioningCompleteResponse
+
+namespace SetTCAcknowledgements {
+static constexpr CommandId Id = 0x00000006;
+} // namespace SetTCAcknowledgements
+
+namespace SetTCAcknowledgementsResponse {
+static constexpr CommandId Id = 0x00000007;
+} // namespace SetTCAcknowledgementsResponse
+
+} // namespace Commands
+} // namespace GeneralCommissioning
+
+namespace NetworkCommissioning {
+namespace Commands {
+
+namespace ScanNetworks {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ScanNetworks
+
+namespace ScanNetworksResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ScanNetworksResponse
+
+namespace AddOrUpdateWiFiNetwork {
+static constexpr CommandId Id = 0x00000002;
+} // namespace AddOrUpdateWiFiNetwork
+
+namespace AddOrUpdateThreadNetwork {
+static constexpr CommandId Id = 0x00000003;
+} // namespace AddOrUpdateThreadNetwork
+
+namespace RemoveNetwork {
+static constexpr CommandId Id = 0x00000004;
+} // namespace RemoveNetwork
+
+namespace NetworkConfigResponse {
+static constexpr CommandId Id = 0x00000005;
+} // namespace NetworkConfigResponse
+
+namespace ConnectNetwork {
+static constexpr CommandId Id = 0x00000006;
+} // namespace ConnectNetwork
+
+namespace ConnectNetworkResponse {
+static constexpr CommandId Id = 0x00000007;
+} // namespace ConnectNetworkResponse
+
+namespace ReorderNetwork {
+static constexpr CommandId Id = 0x00000008;
+} // namespace ReorderNetwork
+
+namespace QueryIdentity {
+static constexpr CommandId Id = 0x00000009;
+} // namespace QueryIdentity
+
+namespace QueryIdentityResponse {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace QueryIdentityResponse
+
+} // namespace Commands
+} // namespace NetworkCommissioning
+
+namespace DiagnosticLogs {
+namespace Commands {
+
+namespace RetrieveLogsRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace RetrieveLogsRequest
+
+namespace RetrieveLogsResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace RetrieveLogsResponse
+
+} // namespace Commands
+} // namespace DiagnosticLogs
+
+namespace GeneralDiagnostics {
+namespace Commands {
+
+namespace TestEventTrigger {
+static constexpr CommandId Id = 0x00000000;
+} // namespace TestEventTrigger
+
+namespace TimeSnapshot {
+static constexpr CommandId Id = 0x00000001;
+} // namespace TimeSnapshot
+
+namespace TimeSnapshotResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace TimeSnapshotResponse
+
+namespace PayloadTestRequest {
+static constexpr CommandId Id = 0x00000003;
+} // namespace PayloadTestRequest
+
+namespace PayloadTestResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace PayloadTestResponse
+
+} // namespace Commands
+} // namespace GeneralDiagnostics
+
+namespace SoftwareDiagnostics {
+namespace Commands {
+
+namespace ResetWatermarks {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ResetWatermarks
+
+} // namespace Commands
+} // namespace SoftwareDiagnostics
+
+namespace ThreadNetworkDiagnostics {
+namespace Commands {
+
+namespace ResetCounts {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ResetCounts
+
+} // namespace Commands
+} // namespace ThreadNetworkDiagnostics
+
+namespace WiFiNetworkDiagnostics {
+namespace Commands {
+
+namespace ResetCounts {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ResetCounts
+
+} // namespace Commands
+} // namespace WiFiNetworkDiagnostics
+
+namespace EthernetNetworkDiagnostics {
+namespace Commands {
+
+namespace ResetCounts {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ResetCounts
+
+} // namespace Commands
+} // namespace EthernetNetworkDiagnostics
+
+namespace TimeSynchronization {
+namespace Commands {
+
+namespace SetUTCTime {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SetUTCTime
+
+namespace SetTrustedTimeSource {
+static constexpr CommandId Id = 0x00000001;
+} // namespace SetTrustedTimeSource
+
+namespace SetTimeZone {
+static constexpr CommandId Id = 0x00000002;
+} // namespace SetTimeZone
+
+namespace SetTimeZoneResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace SetTimeZoneResponse
+
+namespace SetDSTOffset {
+static constexpr CommandId Id = 0x00000004;
+} // namespace SetDSTOffset
+
+namespace SetDefaultNTP {
+static constexpr CommandId Id = 0x00000005;
+} // namespace SetDefaultNTP
+
+} // namespace Commands
+} // namespace TimeSynchronization
+
+namespace BridgedDeviceBasicInformation {
+namespace Commands {
+
+namespace KeepActive {
+static constexpr CommandId Id = 0x00000080;
+} // namespace KeepActive
+
+} // namespace Commands
+} // namespace BridgedDeviceBasicInformation
+
+namespace AdministratorCommissioning {
+namespace Commands {
+
+namespace OpenCommissioningWindow {
+static constexpr CommandId Id = 0x00000000;
+} // namespace OpenCommissioningWindow
+
+namespace OpenBasicCommissioningWindow {
+static constexpr CommandId Id = 0x00000001;
+} // namespace OpenBasicCommissioningWindow
+
+namespace RevokeCommissioning {
+static constexpr CommandId Id = 0x00000002;
+} // namespace RevokeCommissioning
+
+} // namespace Commands
+} // namespace AdministratorCommissioning
+
+namespace OperationalCredentials {
+namespace Commands {
+
+namespace AttestationRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AttestationRequest
+
+namespace AttestationResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace AttestationResponse
+
+namespace CertificateChainRequest {
+static constexpr CommandId Id = 0x00000002;
+} // namespace CertificateChainRequest
+
+namespace CertificateChainResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace CertificateChainResponse
+
+namespace CSRRequest {
+static constexpr CommandId Id = 0x00000004;
+} // namespace CSRRequest
+
+namespace CSRResponse {
+static constexpr CommandId Id = 0x00000005;
+} // namespace CSRResponse
+
+namespace AddNOC {
+static constexpr CommandId Id = 0x00000006;
+} // namespace AddNOC
+
+namespace UpdateNOC {
+static constexpr CommandId Id = 0x00000007;
+} // namespace UpdateNOC
+
+namespace NOCResponse {
+static constexpr CommandId Id = 0x00000008;
+} // namespace NOCResponse
+
+namespace UpdateFabricLabel {
+static constexpr CommandId Id = 0x00000009;
+} // namespace UpdateFabricLabel
+
+namespace RemoveFabric {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace RemoveFabric
+
+namespace AddTrustedRootCertificate {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace AddTrustedRootCertificate
+
+} // namespace Commands
+} // namespace OperationalCredentials
+
+namespace GroupKeyManagement {
+namespace Commands {
+
+namespace KeySetWrite {
+static constexpr CommandId Id = 0x00000000;
+} // namespace KeySetWrite
+
+namespace KeySetRead {
+static constexpr CommandId Id = 0x00000001;
+} // namespace KeySetRead
+
+namespace KeySetReadResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace KeySetReadResponse
+
+namespace KeySetRemove {
+static constexpr CommandId Id = 0x00000003;
+} // namespace KeySetRemove
+
+namespace KeySetReadAllIndices {
+static constexpr CommandId Id = 0x00000004;
+} // namespace KeySetReadAllIndices
+
+namespace KeySetReadAllIndicesResponse {
+static constexpr CommandId Id = 0x00000005;
+} // namespace KeySetReadAllIndicesResponse
+
+} // namespace Commands
+} // namespace GroupKeyManagement
+
+namespace IcdManagement {
+namespace Commands {
+
+namespace RegisterClient {
+static constexpr CommandId Id = 0x00000000;
+} // namespace RegisterClient
+
+namespace RegisterClientResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace RegisterClientResponse
+
+namespace UnregisterClient {
+static constexpr CommandId Id = 0x00000002;
+} // namespace UnregisterClient
+
+namespace StayActiveRequest {
+static constexpr CommandId Id = 0x00000003;
+} // namespace StayActiveRequest
+
+namespace StayActiveResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace StayActiveResponse
+
+} // namespace Commands
+} // namespace IcdManagement
+
+namespace Timer {
+namespace Commands {
+
+namespace SetTimer {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SetTimer
+
+namespace ResetTimer {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ResetTimer
+
+namespace AddTime {
+static constexpr CommandId Id = 0x00000002;
+} // namespace AddTime
+
+namespace ReduceTime {
+static constexpr CommandId Id = 0x00000003;
+} // namespace ReduceTime
+
+} // namespace Commands
+} // namespace Timer
+
+namespace OvenCavityOperationalState {
+namespace Commands {
+
+namespace Pause {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Pause
+
+namespace Stop {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Stop
+
+namespace Start {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Start
+
+namespace Resume {
+static constexpr CommandId Id = 0x00000003;
+} // namespace Resume
+
+namespace OperationalCommandResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace OperationalCommandResponse
+
+} // namespace Commands
+} // namespace OvenCavityOperationalState
+
+namespace OvenMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace OvenMode
+
+namespace ModeSelect {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+} // namespace Commands
+} // namespace ModeSelect
+
+namespace LaundryWasherMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace LaundryWasherMode
+
+namespace RefrigeratorAndTemperatureControlledCabinetMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace RefrigeratorAndTemperatureControlledCabinetMode
+
+namespace RvcRunMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace RvcRunMode
+
+namespace RvcCleanMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace RvcCleanMode
+
+namespace TemperatureControl {
+namespace Commands {
+
+namespace SetTemperature {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SetTemperature
+
+} // namespace Commands
+} // namespace TemperatureControl
+
+namespace DishwasherMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace DishwasherMode
+
+namespace SmokeCoAlarm {
+namespace Commands {
+
+namespace SelfTestRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SelfTestRequest
+
+} // namespace Commands
+} // namespace SmokeCoAlarm
+
+namespace DishwasherAlarm {
+namespace Commands {
+
+namespace Reset {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Reset
+
+namespace ModifyEnabledAlarms {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ModifyEnabledAlarms
+
+} // namespace Commands
+} // namespace DishwasherAlarm
+
+namespace MicrowaveOvenControl {
+namespace Commands {
+
+namespace SetCookingParameters {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SetCookingParameters
+
+namespace AddMoreTime {
+static constexpr CommandId Id = 0x00000001;
+} // namespace AddMoreTime
+
+} // namespace Commands
+} // namespace MicrowaveOvenControl
+
+namespace OperationalState {
+namespace Commands {
+
+namespace Pause {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Pause
+
+namespace Stop {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Stop
+
+namespace Start {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Start
+
+namespace Resume {
+static constexpr CommandId Id = 0x00000003;
+} // namespace Resume
+
+namespace OperationalCommandResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace OperationalCommandResponse
+
+} // namespace Commands
+} // namespace OperationalState
+
+namespace RvcOperationalState {
+namespace Commands {
+
+namespace Pause {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Pause
+
+namespace Resume {
+static constexpr CommandId Id = 0x00000003;
+} // namespace Resume
+
+namespace OperationalCommandResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace OperationalCommandResponse
+
+namespace GoHome {
+static constexpr CommandId Id = 0x00000080;
+} // namespace GoHome
+
+} // namespace Commands
+} // namespace RvcOperationalState
+
+namespace ScenesManagement {
+namespace Commands {
+
+namespace AddScene {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AddScene
+
+namespace AddSceneResponse {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AddSceneResponse
+
+namespace ViewScene {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ViewScene
+
+namespace ViewSceneResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ViewSceneResponse
+
+namespace RemoveScene {
+static constexpr CommandId Id = 0x00000002;
+} // namespace RemoveScene
+
+namespace RemoveSceneResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace RemoveSceneResponse
+
+namespace RemoveAllScenes {
+static constexpr CommandId Id = 0x00000003;
+} // namespace RemoveAllScenes
+
+namespace RemoveAllScenesResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace RemoveAllScenesResponse
+
+namespace StoreScene {
+static constexpr CommandId Id = 0x00000004;
+} // namespace StoreScene
+
+namespace StoreSceneResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace StoreSceneResponse
+
+namespace RecallScene {
+static constexpr CommandId Id = 0x00000005;
+} // namespace RecallScene
+
+namespace GetSceneMembership {
+static constexpr CommandId Id = 0x00000006;
+} // namespace GetSceneMembership
+
+namespace GetSceneMembershipResponse {
+static constexpr CommandId Id = 0x00000006;
+} // namespace GetSceneMembershipResponse
+
+namespace CopyScene {
+static constexpr CommandId Id = 0x00000040;
+} // namespace CopyScene
+
+namespace CopySceneResponse {
+static constexpr CommandId Id = 0x00000040;
+} // namespace CopySceneResponse
+
+} // namespace Commands
+} // namespace ScenesManagement
+
+namespace HepaFilterMonitoring {
+namespace Commands {
+
+namespace ResetCondition {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ResetCondition
+
+} // namespace Commands
+} // namespace HepaFilterMonitoring
+
+namespace ActivatedCarbonFilterMonitoring {
+namespace Commands {
+
+namespace ResetCondition {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ResetCondition
+
+} // namespace Commands
+} // namespace ActivatedCarbonFilterMonitoring
+
+namespace BooleanStateConfiguration {
+namespace Commands {
+
+namespace SuppressAlarm {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SuppressAlarm
+
+namespace EnableDisableAlarm {
+static constexpr CommandId Id = 0x00000001;
+} // namespace EnableDisableAlarm
+
+} // namespace Commands
+} // namespace BooleanStateConfiguration
+
+namespace ValveConfigurationAndControl {
+namespace Commands {
+
+namespace Open {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Open
+
+namespace Close {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Close
+
+} // namespace Commands
+} // namespace ValveConfigurationAndControl
+
+namespace WaterHeaterManagement {
+namespace Commands {
+
+namespace Boost {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Boost
+
+namespace CancelBoost {
+static constexpr CommandId Id = 0x00000001;
+} // namespace CancelBoost
+
+} // namespace Commands
+} // namespace WaterHeaterManagement
+
+namespace DemandResponseLoadControl {
+namespace Commands {
+
+namespace RegisterLoadControlProgramRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace RegisterLoadControlProgramRequest
+
+namespace UnregisterLoadControlProgramRequest {
+static constexpr CommandId Id = 0x00000001;
+} // namespace UnregisterLoadControlProgramRequest
+
+namespace AddLoadControlEventRequest {
+static constexpr CommandId Id = 0x00000002;
+} // namespace AddLoadControlEventRequest
+
+namespace RemoveLoadControlEventRequest {
+static constexpr CommandId Id = 0x00000003;
+} // namespace RemoveLoadControlEventRequest
+
+namespace ClearLoadControlEventsRequest {
+static constexpr CommandId Id = 0x00000004;
+} // namespace ClearLoadControlEventsRequest
+
+} // namespace Commands
+} // namespace DemandResponseLoadControl
+
+namespace Messages {
+namespace Commands {
+
+namespace PresentMessagesRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace PresentMessagesRequest
+
+namespace CancelMessagesRequest {
+static constexpr CommandId Id = 0x00000001;
+} // namespace CancelMessagesRequest
+
+} // namespace Commands
+} // namespace Messages
+
+namespace DeviceEnergyManagement {
+namespace Commands {
+
+namespace PowerAdjustRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace PowerAdjustRequest
+
+namespace CancelPowerAdjustRequest {
+static constexpr CommandId Id = 0x00000001;
+} // namespace CancelPowerAdjustRequest
+
+namespace StartTimeAdjustRequest {
+static constexpr CommandId Id = 0x00000002;
+} // namespace StartTimeAdjustRequest
+
+namespace PauseRequest {
+static constexpr CommandId Id = 0x00000003;
+} // namespace PauseRequest
+
+namespace ResumeRequest {
+static constexpr CommandId Id = 0x00000004;
+} // namespace ResumeRequest
+
+namespace ModifyForecastRequest {
+static constexpr CommandId Id = 0x00000005;
+} // namespace ModifyForecastRequest
+
+namespace RequestConstraintBasedForecast {
+static constexpr CommandId Id = 0x00000006;
+} // namespace RequestConstraintBasedForecast
+
+namespace CancelRequest {
+static constexpr CommandId Id = 0x00000007;
+} // namespace CancelRequest
+
+} // namespace Commands
+} // namespace DeviceEnergyManagement
+
+namespace EnergyEvse {
+namespace Commands {
+
+namespace GetTargetsResponse {
+static constexpr CommandId Id = 0x00000000;
+} // namespace GetTargetsResponse
+
+namespace Disable {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Disable
+
+namespace EnableCharging {
+static constexpr CommandId Id = 0x00000002;
+} // namespace EnableCharging
+
+namespace EnableDischarging {
+static constexpr CommandId Id = 0x00000003;
+} // namespace EnableDischarging
+
+namespace StartDiagnostics {
+static constexpr CommandId Id = 0x00000004;
+} // namespace StartDiagnostics
+
+namespace SetTargets {
+static constexpr CommandId Id = 0x00000005;
+} // namespace SetTargets
+
+namespace GetTargets {
+static constexpr CommandId Id = 0x00000006;
+} // namespace GetTargets
+
+namespace ClearTargets {
+static constexpr CommandId Id = 0x00000007;
+} // namespace ClearTargets
+
+} // namespace Commands
+} // namespace EnergyEvse
+
+namespace EnergyEvseMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace EnergyEvseMode
+
+namespace WaterHeaterMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace WaterHeaterMode
+
+namespace DeviceEnergyManagementMode {
+namespace Commands {
+
+namespace ChangeToMode {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeToMode
+
+namespace ChangeToModeResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeToModeResponse
+
+} // namespace Commands
+} // namespace DeviceEnergyManagementMode
+
+namespace DoorLock {
+namespace Commands {
+
+namespace LockDoor {
+static constexpr CommandId Id = 0x00000000;
+} // namespace LockDoor
+
+namespace UnlockDoor {
+static constexpr CommandId Id = 0x00000001;
+} // namespace UnlockDoor
+
+namespace UnlockWithTimeout {
+static constexpr CommandId Id = 0x00000003;
+} // namespace UnlockWithTimeout
+
+namespace SetWeekDaySchedule {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace SetWeekDaySchedule
+
+namespace GetWeekDaySchedule {
+static constexpr CommandId Id = 0x0000000C;
+} // namespace GetWeekDaySchedule
+
+namespace GetWeekDayScheduleResponse {
+static constexpr CommandId Id = 0x0000000C;
+} // namespace GetWeekDayScheduleResponse
+
+namespace ClearWeekDaySchedule {
+static constexpr CommandId Id = 0x0000000D;
+} // namespace ClearWeekDaySchedule
+
+namespace SetYearDaySchedule {
+static constexpr CommandId Id = 0x0000000E;
+} // namespace SetYearDaySchedule
+
+namespace GetYearDaySchedule {
+static constexpr CommandId Id = 0x0000000F;
+} // namespace GetYearDaySchedule
+
+namespace GetYearDayScheduleResponse {
+static constexpr CommandId Id = 0x0000000F;
+} // namespace GetYearDayScheduleResponse
+
+namespace ClearYearDaySchedule {
+static constexpr CommandId Id = 0x00000010;
+} // namespace ClearYearDaySchedule
+
+namespace SetHolidaySchedule {
+static constexpr CommandId Id = 0x00000011;
+} // namespace SetHolidaySchedule
+
+namespace GetHolidaySchedule {
+static constexpr CommandId Id = 0x00000012;
+} // namespace GetHolidaySchedule
+
+namespace GetHolidayScheduleResponse {
+static constexpr CommandId Id = 0x00000012;
+} // namespace GetHolidayScheduleResponse
+
+namespace ClearHolidaySchedule {
+static constexpr CommandId Id = 0x00000013;
+} // namespace ClearHolidaySchedule
+
+namespace SetUser {
+static constexpr CommandId Id = 0x0000001A;
+} // namespace SetUser
+
+namespace GetUser {
+static constexpr CommandId Id = 0x0000001B;
+} // namespace GetUser
+
+namespace GetUserResponse {
+static constexpr CommandId Id = 0x0000001C;
+} // namespace GetUserResponse
+
+namespace ClearUser {
+static constexpr CommandId Id = 0x0000001D;
+} // namespace ClearUser
+
+namespace SetCredential {
+static constexpr CommandId Id = 0x00000022;
+} // namespace SetCredential
+
+namespace SetCredentialResponse {
+static constexpr CommandId Id = 0x00000023;
+} // namespace SetCredentialResponse
+
+namespace GetCredentialStatus {
+static constexpr CommandId Id = 0x00000024;
+} // namespace GetCredentialStatus
+
+namespace GetCredentialStatusResponse {
+static constexpr CommandId Id = 0x00000025;
+} // namespace GetCredentialStatusResponse
+
+namespace ClearCredential {
+static constexpr CommandId Id = 0x00000026;
+} // namespace ClearCredential
+
+namespace UnboltDoor {
+static constexpr CommandId Id = 0x00000027;
+} // namespace UnboltDoor
+
+namespace SetAliroReaderConfig {
+static constexpr CommandId Id = 0x00000028;
+} // namespace SetAliroReaderConfig
+
+namespace ClearAliroReaderConfig {
+static constexpr CommandId Id = 0x00000029;
+} // namespace ClearAliroReaderConfig
+
+} // namespace Commands
+} // namespace DoorLock
+
+namespace WindowCovering {
+namespace Commands {
+
+namespace UpOrOpen {
+static constexpr CommandId Id = 0x00000000;
+} // namespace UpOrOpen
+
+namespace DownOrClose {
+static constexpr CommandId Id = 0x00000001;
+} // namespace DownOrClose
+
+namespace StopMotion {
+static constexpr CommandId Id = 0x00000002;
+} // namespace StopMotion
+
+namespace GoToLiftValue {
+static constexpr CommandId Id = 0x00000004;
+} // namespace GoToLiftValue
+
+namespace GoToLiftPercentage {
+static constexpr CommandId Id = 0x00000005;
+} // namespace GoToLiftPercentage
+
+namespace GoToTiltValue {
+static constexpr CommandId Id = 0x00000007;
+} // namespace GoToTiltValue
+
+namespace GoToTiltPercentage {
+static constexpr CommandId Id = 0x00000008;
+} // namespace GoToTiltPercentage
+
+} // namespace Commands
+} // namespace WindowCovering
+
+namespace ServiceArea {
+namespace Commands {
+
+namespace SelectAreas {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SelectAreas
+
+namespace SelectAreasResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace SelectAreasResponse
+
+namespace SkipArea {
+static constexpr CommandId Id = 0x00000002;
+} // namespace SkipArea
+
+namespace SkipAreaResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace SkipAreaResponse
+
+} // namespace Commands
+} // namespace ServiceArea
+
+namespace Thermostat {
+namespace Commands {
+
+namespace SetpointRaiseLower {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SetpointRaiseLower
+
+namespace GetWeeklyScheduleResponse {
+static constexpr CommandId Id = 0x00000000;
+} // namespace GetWeeklyScheduleResponse
+
+namespace SetWeeklySchedule {
+static constexpr CommandId Id = 0x00000001;
+} // namespace SetWeeklySchedule
+
+namespace GetWeeklySchedule {
+static constexpr CommandId Id = 0x00000002;
+} // namespace GetWeeklySchedule
+
+namespace ClearWeeklySchedule {
+static constexpr CommandId Id = 0x00000003;
+} // namespace ClearWeeklySchedule
+
+namespace SetActiveScheduleRequest {
+static constexpr CommandId Id = 0x00000005;
+} // namespace SetActiveScheduleRequest
+
+namespace SetActivePresetRequest {
+static constexpr CommandId Id = 0x00000006;
+} // namespace SetActivePresetRequest
+
+namespace AtomicResponse {
+static constexpr CommandId Id = 0x000000FD;
+} // namespace AtomicResponse
+
+namespace AtomicRequest {
+static constexpr CommandId Id = 0x000000FE;
+} // namespace AtomicRequest
+
+} // namespace Commands
+} // namespace Thermostat
+
+namespace FanControl {
+namespace Commands {
+
+namespace Step {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Step
+
+} // namespace Commands
+} // namespace FanControl
+
+namespace ColorControl {
+namespace Commands {
+
+namespace MoveToHue {
+static constexpr CommandId Id = 0x00000000;
+} // namespace MoveToHue
+
+namespace MoveHue {
+static constexpr CommandId Id = 0x00000001;
+} // namespace MoveHue
+
+namespace StepHue {
+static constexpr CommandId Id = 0x00000002;
+} // namespace StepHue
+
+namespace MoveToSaturation {
+static constexpr CommandId Id = 0x00000003;
+} // namespace MoveToSaturation
+
+namespace MoveSaturation {
+static constexpr CommandId Id = 0x00000004;
+} // namespace MoveSaturation
+
+namespace StepSaturation {
+static constexpr CommandId Id = 0x00000005;
+} // namespace StepSaturation
+
+namespace MoveToHueAndSaturation {
+static constexpr CommandId Id = 0x00000006;
+} // namespace MoveToHueAndSaturation
+
+namespace MoveToColor {
+static constexpr CommandId Id = 0x00000007;
+} // namespace MoveToColor
+
+namespace MoveColor {
+static constexpr CommandId Id = 0x00000008;
+} // namespace MoveColor
+
+namespace StepColor {
+static constexpr CommandId Id = 0x00000009;
+} // namespace StepColor
+
+namespace MoveToColorTemperature {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace MoveToColorTemperature
+
+namespace EnhancedMoveToHue {
+static constexpr CommandId Id = 0x00000040;
+} // namespace EnhancedMoveToHue
+
+namespace EnhancedMoveHue {
+static constexpr CommandId Id = 0x00000041;
+} // namespace EnhancedMoveHue
+
+namespace EnhancedStepHue {
+static constexpr CommandId Id = 0x00000042;
+} // namespace EnhancedStepHue
+
+namespace EnhancedMoveToHueAndSaturation {
+static constexpr CommandId Id = 0x00000043;
+} // namespace EnhancedMoveToHueAndSaturation
+
+namespace ColorLoopSet {
+static constexpr CommandId Id = 0x00000044;
+} // namespace ColorLoopSet
+
+namespace StopMoveStep {
+static constexpr CommandId Id = 0x00000047;
+} // namespace StopMoveStep
+
+namespace MoveColorTemperature {
+static constexpr CommandId Id = 0x0000004B;
+} // namespace MoveColorTemperature
+
+namespace StepColorTemperature {
+static constexpr CommandId Id = 0x0000004C;
+} // namespace StepColorTemperature
+
+} // namespace Commands
+} // namespace ColorControl
+
+namespace WiFiNetworkManagement {
+namespace Commands {
+
+namespace NetworkPassphraseRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace NetworkPassphraseRequest
+
+namespace NetworkPassphraseResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace NetworkPassphraseResponse
+
+} // namespace Commands
+} // namespace WiFiNetworkManagement
+
+namespace ThreadBorderRouterManagement {
+namespace Commands {
+
+namespace GetActiveDatasetRequest {
+static constexpr CommandId Id = 0x00000000;
+} // namespace GetActiveDatasetRequest
+
+namespace GetPendingDatasetRequest {
+static constexpr CommandId Id = 0x00000001;
+} // namespace GetPendingDatasetRequest
+
+namespace DatasetResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace DatasetResponse
+
+namespace SetActiveDatasetRequest {
+static constexpr CommandId Id = 0x00000003;
+} // namespace SetActiveDatasetRequest
+
+namespace SetPendingDatasetRequest {
+static constexpr CommandId Id = 0x00000004;
+} // namespace SetPendingDatasetRequest
+
+} // namespace Commands
+} // namespace ThreadBorderRouterManagement
+
+namespace ThreadNetworkDirectory {
+namespace Commands {
+
+namespace AddNetwork {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AddNetwork
+
+namespace RemoveNetwork {
+static constexpr CommandId Id = 0x00000001;
+} // namespace RemoveNetwork
+
+namespace GetOperationalDataset {
+static constexpr CommandId Id = 0x00000002;
+} // namespace GetOperationalDataset
+
+namespace OperationalDatasetResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace OperationalDatasetResponse
+
+} // namespace Commands
+} // namespace ThreadNetworkDirectory
+
+namespace Channel {
+namespace Commands {
+
+namespace ChangeChannel {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ChangeChannel
+
+namespace ChangeChannelResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ChangeChannelResponse
+
+namespace ChangeChannelByNumber {
+static constexpr CommandId Id = 0x00000002;
+} // namespace ChangeChannelByNumber
+
+namespace SkipChannel {
+static constexpr CommandId Id = 0x00000003;
+} // namespace SkipChannel
+
+namespace GetProgramGuide {
+static constexpr CommandId Id = 0x00000004;
+} // namespace GetProgramGuide
+
+namespace ProgramGuideResponse {
+static constexpr CommandId Id = 0x00000005;
+} // namespace ProgramGuideResponse
+
+namespace RecordProgram {
+static constexpr CommandId Id = 0x00000006;
+} // namespace RecordProgram
+
+namespace CancelRecordProgram {
+static constexpr CommandId Id = 0x00000007;
+} // namespace CancelRecordProgram
+
+} // namespace Commands
+} // namespace Channel
+
+namespace TargetNavigator {
+namespace Commands {
+
+namespace NavigateTarget {
+static constexpr CommandId Id = 0x00000000;
+} // namespace NavigateTarget
+
+namespace NavigateTargetResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace NavigateTargetResponse
+
+} // namespace Commands
+} // namespace TargetNavigator
+
+namespace MediaPlayback {
+namespace Commands {
+
+namespace Play {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Play
+
+namespace Pause {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Pause
+
+namespace Stop {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Stop
+
+namespace StartOver {
+static constexpr CommandId Id = 0x00000003;
+} // namespace StartOver
+
+namespace Previous {
+static constexpr CommandId Id = 0x00000004;
+} // namespace Previous
+
+namespace Next {
+static constexpr CommandId Id = 0x00000005;
+} // namespace Next
+
+namespace Rewind {
+static constexpr CommandId Id = 0x00000006;
+} // namespace Rewind
+
+namespace FastForward {
+static constexpr CommandId Id = 0x00000007;
+} // namespace FastForward
+
+namespace SkipForward {
+static constexpr CommandId Id = 0x00000008;
+} // namespace SkipForward
+
+namespace SkipBackward {
+static constexpr CommandId Id = 0x00000009;
+} // namespace SkipBackward
+
+namespace PlaybackResponse {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace PlaybackResponse
+
+namespace Seek {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace Seek
+
+namespace ActivateAudioTrack {
+static constexpr CommandId Id = 0x0000000C;
+} // namespace ActivateAudioTrack
+
+namespace ActivateTextTrack {
+static constexpr CommandId Id = 0x0000000D;
+} // namespace ActivateTextTrack
+
+namespace DeactivateTextTrack {
+static constexpr CommandId Id = 0x0000000E;
+} // namespace DeactivateTextTrack
+
+} // namespace Commands
+} // namespace MediaPlayback
+
+namespace MediaInput {
+namespace Commands {
+
+namespace SelectInput {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SelectInput
+
+namespace ShowInputStatus {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ShowInputStatus
+
+namespace HideInputStatus {
+static constexpr CommandId Id = 0x00000002;
+} // namespace HideInputStatus
+
+namespace RenameInput {
+static constexpr CommandId Id = 0x00000003;
+} // namespace RenameInput
+
+} // namespace Commands
+} // namespace MediaInput
+
+namespace LowPower {
+namespace Commands {
+
+namespace Sleep {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Sleep
+
+} // namespace Commands
+} // namespace LowPower
+
+namespace KeypadInput {
+namespace Commands {
+
+namespace SendKey {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SendKey
+
+namespace SendKeyResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace SendKeyResponse
+
+} // namespace Commands
+} // namespace KeypadInput
+
+namespace ContentLauncher {
+namespace Commands {
+
+namespace LaunchContent {
+static constexpr CommandId Id = 0x00000000;
+} // namespace LaunchContent
+
+namespace LaunchURL {
+static constexpr CommandId Id = 0x00000001;
+} // namespace LaunchURL
+
+namespace LauncherResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace LauncherResponse
+
+} // namespace Commands
+} // namespace ContentLauncher
+
+namespace AudioOutput {
+namespace Commands {
+
+namespace SelectOutput {
+static constexpr CommandId Id = 0x00000000;
+} // namespace SelectOutput
+
+namespace RenameOutput {
+static constexpr CommandId Id = 0x00000001;
+} // namespace RenameOutput
+
+} // namespace Commands
+} // namespace AudioOutput
+
+namespace ApplicationLauncher {
+namespace Commands {
+
+namespace LaunchApp {
+static constexpr CommandId Id = 0x00000000;
+} // namespace LaunchApp
+
+namespace StopApp {
+static constexpr CommandId Id = 0x00000001;
+} // namespace StopApp
+
+namespace HideApp {
+static constexpr CommandId Id = 0x00000002;
+} // namespace HideApp
+
+namespace LauncherResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace LauncherResponse
+
+} // namespace Commands
+} // namespace ApplicationLauncher
+
+namespace AccountLogin {
+namespace Commands {
+
+namespace GetSetupPIN {
+static constexpr CommandId Id = 0x00000000;
+} // namespace GetSetupPIN
+
+namespace GetSetupPINResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace GetSetupPINResponse
+
+namespace Login {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Login
+
+namespace Logout {
+static constexpr CommandId Id = 0x00000003;
+} // namespace Logout
+
+} // namespace Commands
+} // namespace AccountLogin
+
+namespace ContentControl {
+namespace Commands {
+
+namespace UpdatePIN {
+static constexpr CommandId Id = 0x00000000;
+} // namespace UpdatePIN
+
+namespace ResetPIN {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ResetPIN
+
+namespace ResetPINResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace ResetPINResponse
+
+namespace Enable {
+static constexpr CommandId Id = 0x00000003;
+} // namespace Enable
+
+namespace Disable {
+static constexpr CommandId Id = 0x00000004;
+} // namespace Disable
+
+namespace AddBonusTime {
+static constexpr CommandId Id = 0x00000005;
+} // namespace AddBonusTime
+
+namespace SetScreenDailyTime {
+static constexpr CommandId Id = 0x00000006;
+} // namespace SetScreenDailyTime
+
+namespace BlockUnratedContent {
+static constexpr CommandId Id = 0x00000007;
+} // namespace BlockUnratedContent
+
+namespace UnblockUnratedContent {
+static constexpr CommandId Id = 0x00000008;
+} // namespace UnblockUnratedContent
+
+namespace SetOnDemandRatingThreshold {
+static constexpr CommandId Id = 0x00000009;
+} // namespace SetOnDemandRatingThreshold
+
+namespace SetScheduledContentRatingThreshold {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace SetScheduledContentRatingThreshold
+
+} // namespace Commands
+} // namespace ContentControl
+
+namespace ContentAppObserver {
+namespace Commands {
+
+namespace ContentAppMessage {
+static constexpr CommandId Id = 0x00000000;
+} // namespace ContentAppMessage
+
+namespace ContentAppMessageResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace ContentAppMessageResponse
+
+} // namespace Commands
+} // namespace ContentAppObserver
+
+namespace ZoneManagement {
+namespace Commands {
+
+namespace CreateTwoDCartesianZone {
+static constexpr CommandId Id = 0x00000000;
+} // namespace CreateTwoDCartesianZone
+
+namespace CreateTwoDCartesianZoneResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace CreateTwoDCartesianZoneResponse
+
+namespace UpdateTwoDCartesianZone {
+static constexpr CommandId Id = 0x00000002;
+} // namespace UpdateTwoDCartesianZone
+
+namespace GetTwoDCartesianZone {
+static constexpr CommandId Id = 0x00000003;
+} // namespace GetTwoDCartesianZone
+
+namespace GetTwoDCartesianZoneResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace GetTwoDCartesianZoneResponse
+
+namespace RemoveZone {
+static constexpr CommandId Id = 0x00000005;
+} // namespace RemoveZone
+
+} // namespace Commands
+} // namespace ZoneManagement
+
+namespace CameraAvStreamManagement {
+namespace Commands {
+
+namespace AudioStreamAllocate {
+static constexpr CommandId Id = 0x00000000;
+} // namespace AudioStreamAllocate
+
+namespace AudioStreamAllocateResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace AudioStreamAllocateResponse
+
+namespace AudioStreamDeallocate {
+static constexpr CommandId Id = 0x00000002;
+} // namespace AudioStreamDeallocate
+
+namespace VideoStreamAllocate {
+static constexpr CommandId Id = 0x00000003;
+} // namespace VideoStreamAllocate
+
+namespace VideoStreamAllocateResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace VideoStreamAllocateResponse
+
+namespace VideoStreamModify {
+static constexpr CommandId Id = 0x00000005;
+} // namespace VideoStreamModify
+
+namespace VideoStreamDeallocate {
+static constexpr CommandId Id = 0x00000006;
+} // namespace VideoStreamDeallocate
+
+namespace SnapshotStreamAllocate {
+static constexpr CommandId Id = 0x00000007;
+} // namespace SnapshotStreamAllocate
+
+namespace SnapshotStreamAllocateResponse {
+static constexpr CommandId Id = 0x00000008;
+} // namespace SnapshotStreamAllocateResponse
+
+namespace SnapshotStreamDeallocate {
+static constexpr CommandId Id = 0x00000009;
+} // namespace SnapshotStreamDeallocate
+
+namespace SetStreamPriorities {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace SetStreamPriorities
+
+namespace CaptureSnapshot {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace CaptureSnapshot
+
+namespace CaptureSnapshotResponse {
+static constexpr CommandId Id = 0x0000000C;
+} // namespace CaptureSnapshotResponse
+
+} // namespace Commands
+} // namespace CameraAvStreamManagement
+
+namespace CameraAvSettingsUserLevelManagement {
+namespace Commands {
+
+namespace MPTZSetPosition {
+static constexpr CommandId Id = 0x00000000;
+} // namespace MPTZSetPosition
+
+namespace MPTZRelativeMove {
+static constexpr CommandId Id = 0x00000001;
+} // namespace MPTZRelativeMove
+
+namespace MPTZMoveToPreset {
+static constexpr CommandId Id = 0x00000002;
+} // namespace MPTZMoveToPreset
+
+namespace MPTZSavePreset {
+static constexpr CommandId Id = 0x00000003;
+} // namespace MPTZSavePreset
+
+namespace MPTZRemovePreset {
+static constexpr CommandId Id = 0x00000004;
+} // namespace MPTZRemovePreset
+
+namespace DPTZSetViewport {
+static constexpr CommandId Id = 0x00000005;
+} // namespace DPTZSetViewport
+
+namespace DPTZRelativeMove {
+static constexpr CommandId Id = 0x00000006;
+} // namespace DPTZRelativeMove
+
+} // namespace Commands
+} // namespace CameraAvSettingsUserLevelManagement
+
+namespace WebRTCTransportProvider {
+namespace Commands {
+
+namespace SolicitOffer {
+static constexpr CommandId Id = 0x00000001;
+} // namespace SolicitOffer
+
+namespace SolicitOfferResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace SolicitOfferResponse
+
+namespace ProvideOffer {
+static constexpr CommandId Id = 0x00000003;
+} // namespace ProvideOffer
+
+namespace ProvideOfferResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace ProvideOfferResponse
+
+namespace ProvideAnswer {
+static constexpr CommandId Id = 0x00000005;
+} // namespace ProvideAnswer
+
+namespace ProvideICECandidate {
+static constexpr CommandId Id = 0x00000006;
+} // namespace ProvideICECandidate
+
+namespace EndSession {
+static constexpr CommandId Id = 0x00000007;
+} // namespace EndSession
+
+} // namespace Commands
+} // namespace WebRTCTransportProvider
+
+namespace WebRTCTransportRequestor {
+namespace Commands {
+
+namespace Offer {
+static constexpr CommandId Id = 0x00000001;
+} // namespace Offer
+
+namespace Answer {
+static constexpr CommandId Id = 0x00000002;
+} // namespace Answer
+
+namespace ICECandidate {
+static constexpr CommandId Id = 0x00000003;
+} // namespace ICECandidate
+
+namespace End {
+static constexpr CommandId Id = 0x00000004;
+} // namespace End
+
+} // namespace Commands
+} // namespace WebRTCTransportRequestor
+
+namespace Chime {
+namespace Commands {
+
+namespace PlayChimeSound {
+static constexpr CommandId Id = 0x00000000;
+} // namespace PlayChimeSound
+
+} // namespace Commands
+} // namespace Chime
+
+namespace CommissionerControl {
+namespace Commands {
+
+namespace RequestCommissioningApproval {
+static constexpr CommandId Id = 0x00000000;
+} // namespace RequestCommissioningApproval
+
+namespace CommissionNode {
+static constexpr CommandId Id = 0x00000001;
+} // namespace CommissionNode
+
+namespace ReverseOpenCommissioningWindow {
+static constexpr CommandId Id = 0x00000002;
+} // namespace ReverseOpenCommissioningWindow
+
+} // namespace Commands
+} // namespace CommissionerControl
+
+namespace UnitTesting {
+namespace Commands {
+
+namespace Test {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Test
+
+namespace TestSpecificResponse {
+static constexpr CommandId Id = 0x00000000;
+} // namespace TestSpecificResponse
+
+namespace TestNotHandled {
+static constexpr CommandId Id = 0x00000001;
+} // namespace TestNotHandled
+
+namespace TestAddArgumentsResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace TestAddArgumentsResponse
+
+namespace TestSpecific {
+static constexpr CommandId Id = 0x00000002;
+} // namespace TestSpecific
+
+namespace TestSimpleArgumentResponse {
+static constexpr CommandId Id = 0x00000002;
+} // namespace TestSimpleArgumentResponse
+
+namespace TestUnknownCommand {
+static constexpr CommandId Id = 0x00000003;
+} // namespace TestUnknownCommand
+
+namespace TestStructArrayArgumentResponse {
+static constexpr CommandId Id = 0x00000003;
+} // namespace TestStructArrayArgumentResponse
+
+namespace TestAddArguments {
+static constexpr CommandId Id = 0x00000004;
+} // namespace TestAddArguments
+
+namespace TestListInt8UReverseResponse {
+static constexpr CommandId Id = 0x00000004;
+} // namespace TestListInt8UReverseResponse
+
+namespace TestSimpleArgumentRequest {
+static constexpr CommandId Id = 0x00000005;
+} // namespace TestSimpleArgumentRequest
+
+namespace TestEnumsResponse {
+static constexpr CommandId Id = 0x00000005;
+} // namespace TestEnumsResponse
+
+namespace TestStructArrayArgumentRequest {
+static constexpr CommandId Id = 0x00000006;
+} // namespace TestStructArrayArgumentRequest
+
+namespace TestNullableOptionalResponse {
+static constexpr CommandId Id = 0x00000006;
+} // namespace TestNullableOptionalResponse
+
+namespace TestStructArgumentRequest {
+static constexpr CommandId Id = 0x00000007;
+} // namespace TestStructArgumentRequest
+
+namespace TestComplexNullableOptionalResponse {
+static constexpr CommandId Id = 0x00000007;
+} // namespace TestComplexNullableOptionalResponse
+
+namespace TestNestedStructArgumentRequest {
+static constexpr CommandId Id = 0x00000008;
+} // namespace TestNestedStructArgumentRequest
+
+namespace BooleanResponse {
+static constexpr CommandId Id = 0x00000008;
+} // namespace BooleanResponse
+
+namespace TestListStructArgumentRequest {
+static constexpr CommandId Id = 0x00000009;
+} // namespace TestListStructArgumentRequest
+
+namespace SimpleStructResponse {
+static constexpr CommandId Id = 0x00000009;
+} // namespace SimpleStructResponse
+
+namespace TestListInt8UArgumentRequest {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace TestListInt8UArgumentRequest
+
+namespace TestEmitTestEventResponse {
+static constexpr CommandId Id = 0x0000000A;
+} // namespace TestEmitTestEventResponse
+
+namespace TestNestedStructListArgumentRequest {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace TestNestedStructListArgumentRequest
+
+namespace TestEmitTestFabricScopedEventResponse {
+static constexpr CommandId Id = 0x0000000B;
+} // namespace TestEmitTestFabricScopedEventResponse
+
+namespace TestListNestedStructListArgumentRequest {
+static constexpr CommandId Id = 0x0000000C;
+} // namespace TestListNestedStructListArgumentRequest
+
+namespace TestBatchHelperResponse {
+static constexpr CommandId Id = 0x0000000C;
+} // namespace TestBatchHelperResponse
+
+namespace TestListInt8UReverseRequest {
+static constexpr CommandId Id = 0x0000000D;
+} // namespace TestListInt8UReverseRequest
+
+namespace StringEchoResponse {
+static constexpr CommandId Id = 0x0000000D;
+} // namespace StringEchoResponse
+
+namespace TestEnumsRequest {
+static constexpr CommandId Id = 0x0000000E;
+} // namespace TestEnumsRequest
+
+namespace GlobalEchoResponse {
+static constexpr CommandId Id = 0x0000000E;
+} // namespace GlobalEchoResponse
+
+namespace TestNullableOptionalRequest {
+static constexpr CommandId Id = 0x0000000F;
+} // namespace TestNullableOptionalRequest
+
+namespace TestComplexNullableOptionalRequest {
+static constexpr CommandId Id = 0x00000010;
+} // namespace TestComplexNullableOptionalRequest
+
+namespace SimpleStructEchoRequest {
+static constexpr CommandId Id = 0x00000011;
+} // namespace SimpleStructEchoRequest
+
+namespace TimedInvokeRequest {
+static constexpr CommandId Id = 0x00000012;
+} // namespace TimedInvokeRequest
+
+namespace TestSimpleOptionalArgumentRequest {
+static constexpr CommandId Id = 0x00000013;
+} // namespace TestSimpleOptionalArgumentRequest
+
+namespace TestEmitTestEventRequest {
+static constexpr CommandId Id = 0x00000014;
+} // namespace TestEmitTestEventRequest
+
+namespace TestEmitTestFabricScopedEventRequest {
+static constexpr CommandId Id = 0x00000015;
+} // namespace TestEmitTestFabricScopedEventRequest
+
+namespace TestBatchHelperRequest {
+static constexpr CommandId Id = 0x00000016;
+} // namespace TestBatchHelperRequest
+
+namespace TestSecondBatchHelperRequest {
+static constexpr CommandId Id = 0x00000017;
+} // namespace TestSecondBatchHelperRequest
+
+namespace StringEchoRequest {
+static constexpr CommandId Id = 0x00000018;
+} // namespace StringEchoRequest
+
+namespace GlobalEchoRequest {
+static constexpr CommandId Id = 0x00000019;
+} // namespace GlobalEchoRequest
+
+namespace TestDifferentVendorMeiRequest {
+static constexpr CommandId Id = 0xFFF200AA;
+} // namespace TestDifferentVendorMeiRequest
+
+namespace TestDifferentVendorMeiResponse {
+static constexpr CommandId Id = 0xFFF200BB;
+} // namespace TestDifferentVendorMeiResponse
+
+} // namespace Commands
+} // namespace UnitTesting
+
+namespace FaultInjection {
+namespace Commands {
+
+namespace FailAtFault {
+static constexpr CommandId Id = 0x00000000;
+} // namespace FailAtFault
+
+namespace FailRandomlyAtFault {
+static constexpr CommandId Id = 0x00000001;
+} // namespace FailRandomlyAtFault
+
+} // namespace Commands
+} // namespace FaultInjection
+
+namespace SampleManufacturerSpecific {
+namespace Commands {
+
+namespace Ping {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Ping
+
+namespace AddArgumentsResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace AddArgumentsResponse
+
+namespace AddArguments {
+static constexpr CommandId Id = 0x00000002;
+} // namespace AddArguments
+
+} // namespace Commands
+} // namespace SampleManufacturerSpecific
+
+namespace SampleExternalManufacturerSpecific {
+namespace Commands {
+
+namespace Ping {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Ping
+
+namespace AddArgumentsResponse {
+static constexpr CommandId Id = 0x00000001;
+} // namespace AddArgumentsResponse
+
+namespace AddArguments {
+static constexpr CommandId Id = 0x00000002;
+} // namespace AddArguments
+
+} // namespace Commands
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Events.h b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Events.h
new file mode 100644
index 00000000000000..15bf49f9159bf0
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/manufacturer-specific/zzz_generated/app-common/app-common/zap-generated/ids/Events.h
@@ -0,0 +1,768 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+#pragma once
+
+#include <app/util/basic-types.h>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+namespace AccessControl {
+namespace Events {
+
+namespace AccessControlEntryChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace AccessControlEntryChanged
+
+namespace AccessControlExtensionChanged {
+static constexpr EventId Id = 0x00000001;
+} // namespace AccessControlExtensionChanged
+
+namespace FabricRestrictionReviewUpdate {
+static constexpr EventId Id = 0x00000002;
+} // namespace FabricRestrictionReviewUpdate
+
+} // namespace Events
+} // namespace AccessControl
+
+namespace Actions {
+namespace Events {
+
+namespace StateChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace StateChanged
+
+namespace ActionFailed {
+static constexpr EventId Id = 0x00000001;
+} // namespace ActionFailed
+
+} // namespace Events
+} // namespace Actions
+
+namespace BasicInformation {
+namespace Events {
+
+namespace StartUp {
+static constexpr EventId Id = 0x00000000;
+} // namespace StartUp
+
+namespace ShutDown {
+static constexpr EventId Id = 0x00000001;
+} // namespace ShutDown
+
+namespace Leave {
+static constexpr EventId Id = 0x00000002;
+} // namespace Leave
+
+namespace ReachableChanged {
+static constexpr EventId Id = 0x00000003;
+} // namespace ReachableChanged
+
+} // namespace Events
+} // namespace BasicInformation
+
+namespace OtaSoftwareUpdateRequestor {
+namespace Events {
+
+namespace StateTransition {
+static constexpr EventId Id = 0x00000000;
+} // namespace StateTransition
+
+namespace VersionApplied {
+static constexpr EventId Id = 0x00000001;
+} // namespace VersionApplied
+
+namespace DownloadError {
+static constexpr EventId Id = 0x00000002;
+} // namespace DownloadError
+
+} // namespace Events
+} // namespace OtaSoftwareUpdateRequestor
+
+namespace PowerSource {
+namespace Events {
+
+namespace WiredFaultChange {
+static constexpr EventId Id = 0x00000000;
+} // namespace WiredFaultChange
+
+namespace BatFaultChange {
+static constexpr EventId Id = 0x00000001;
+} // namespace BatFaultChange
+
+namespace BatChargeFaultChange {
+static constexpr EventId Id = 0x00000002;
+} // namespace BatChargeFaultChange
+
+} // namespace Events
+} // namespace PowerSource
+
+namespace GeneralDiagnostics {
+namespace Events {
+
+namespace HardwareFaultChange {
+static constexpr EventId Id = 0x00000000;
+} // namespace HardwareFaultChange
+
+namespace RadioFaultChange {
+static constexpr EventId Id = 0x00000001;
+} // namespace RadioFaultChange
+
+namespace NetworkFaultChange {
+static constexpr EventId Id = 0x00000002;
+} // namespace NetworkFaultChange
+
+namespace BootReason {
+static constexpr EventId Id = 0x00000003;
+} // namespace BootReason
+
+} // namespace Events
+} // namespace GeneralDiagnostics
+
+namespace SoftwareDiagnostics {
+namespace Events {
+
+namespace SoftwareFault {
+static constexpr EventId Id = 0x00000000;
+} // namespace SoftwareFault
+
+} // namespace Events
+} // namespace SoftwareDiagnostics
+
+namespace ThreadNetworkDiagnostics {
+namespace Events {
+
+namespace ConnectionStatus {
+static constexpr EventId Id = 0x00000000;
+} // namespace ConnectionStatus
+
+namespace NetworkFaultChange {
+static constexpr EventId Id = 0x00000001;
+} // namespace NetworkFaultChange
+
+} // namespace Events
+} // namespace ThreadNetworkDiagnostics
+
+namespace WiFiNetworkDiagnostics {
+namespace Events {
+
+namespace Disconnection {
+static constexpr EventId Id = 0x00000000;
+} // namespace Disconnection
+
+namespace AssociationFailure {
+static constexpr EventId Id = 0x00000001;
+} // namespace AssociationFailure
+
+namespace ConnectionStatus {
+static constexpr EventId Id = 0x00000002;
+} // namespace ConnectionStatus
+
+} // namespace Events
+} // namespace WiFiNetworkDiagnostics
+
+namespace TimeSynchronization {
+namespace Events {
+
+namespace DSTTableEmpty {
+static constexpr EventId Id = 0x00000000;
+} // namespace DSTTableEmpty
+
+namespace DSTStatus {
+static constexpr EventId Id = 0x00000001;
+} // namespace DSTStatus
+
+namespace TimeZoneStatus {
+static constexpr EventId Id = 0x00000002;
+} // namespace TimeZoneStatus
+
+namespace TimeFailure {
+static constexpr EventId Id = 0x00000003;
+} // namespace TimeFailure
+
+namespace MissingTrustedTimeSource {
+static constexpr EventId Id = 0x00000004;
+} // namespace MissingTrustedTimeSource
+
+} // namespace Events
+} // namespace TimeSynchronization
+
+namespace BridgedDeviceBasicInformation {
+namespace Events {
+
+namespace StartUp {
+static constexpr EventId Id = 0x00000000;
+} // namespace StartUp
+
+namespace ShutDown {
+static constexpr EventId Id = 0x00000001;
+} // namespace ShutDown
+
+namespace Leave {
+static constexpr EventId Id = 0x00000002;
+} // namespace Leave
+
+namespace ReachableChanged {
+static constexpr EventId Id = 0x00000003;
+} // namespace ReachableChanged
+
+namespace ActiveChanged {
+static constexpr EventId Id = 0x00000080;
+} // namespace ActiveChanged
+
+} // namespace Events
+} // namespace BridgedDeviceBasicInformation
+
+namespace Switch {
+namespace Events {
+
+namespace SwitchLatched {
+static constexpr EventId Id = 0x00000000;
+} // namespace SwitchLatched
+
+namespace InitialPress {
+static constexpr EventId Id = 0x00000001;
+} // namespace InitialPress
+
+namespace LongPress {
+static constexpr EventId Id = 0x00000002;
+} // namespace LongPress
+
+namespace ShortRelease {
+static constexpr EventId Id = 0x00000003;
+} // namespace ShortRelease
+
+namespace LongRelease {
+static constexpr EventId Id = 0x00000004;
+} // namespace LongRelease
+
+namespace MultiPressOngoing {
+static constexpr EventId Id = 0x00000005;
+} // namespace MultiPressOngoing
+
+namespace MultiPressComplete {
+static constexpr EventId Id = 0x00000006;
+} // namespace MultiPressComplete
+
+} // namespace Events
+} // namespace Switch
+
+namespace BooleanState {
+namespace Events {
+
+namespace StateChange {
+static constexpr EventId Id = 0x00000000;
+} // namespace StateChange
+
+} // namespace Events
+} // namespace BooleanState
+
+namespace OvenCavityOperationalState {
+namespace Events {
+
+namespace OperationalError {
+static constexpr EventId Id = 0x00000000;
+} // namespace OperationalError
+
+namespace OperationCompletion {
+static constexpr EventId Id = 0x00000001;
+} // namespace OperationCompletion
+
+} // namespace Events
+} // namespace OvenCavityOperationalState
+
+namespace RefrigeratorAlarm {
+namespace Events {
+
+namespace Notify {
+static constexpr EventId Id = 0x00000000;
+} // namespace Notify
+
+} // namespace Events
+} // namespace RefrigeratorAlarm
+
+namespace SmokeCoAlarm {
+namespace Events {
+
+namespace SmokeAlarm {
+static constexpr EventId Id = 0x00000000;
+} // namespace SmokeAlarm
+
+namespace COAlarm {
+static constexpr EventId Id = 0x00000001;
+} // namespace COAlarm
+
+namespace LowBattery {
+static constexpr EventId Id = 0x00000002;
+} // namespace LowBattery
+
+namespace HardwareFault {
+static constexpr EventId Id = 0x00000003;
+} // namespace HardwareFault
+
+namespace EndOfService {
+static constexpr EventId Id = 0x00000004;
+} // namespace EndOfService
+
+namespace SelfTestComplete {
+static constexpr EventId Id = 0x00000005;
+} // namespace SelfTestComplete
+
+namespace AlarmMuted {
+static constexpr EventId Id = 0x00000006;
+} // namespace AlarmMuted
+
+namespace MuteEnded {
+static constexpr EventId Id = 0x00000007;
+} // namespace MuteEnded
+
+namespace InterconnectSmokeAlarm {
+static constexpr EventId Id = 0x00000008;
+} // namespace InterconnectSmokeAlarm
+
+namespace InterconnectCOAlarm {
+static constexpr EventId Id = 0x00000009;
+} // namespace InterconnectCOAlarm
+
+namespace AllClear {
+static constexpr EventId Id = 0x0000000A;
+} // namespace AllClear
+
+} // namespace Events
+} // namespace SmokeCoAlarm
+
+namespace DishwasherAlarm {
+namespace Events {
+
+namespace Notify {
+static constexpr EventId Id = 0x00000000;
+} // namespace Notify
+
+} // namespace Events
+} // namespace DishwasherAlarm
+
+namespace OperationalState {
+namespace Events {
+
+namespace OperationalError {
+static constexpr EventId Id = 0x00000000;
+} // namespace OperationalError
+
+namespace OperationCompletion {
+static constexpr EventId Id = 0x00000001;
+} // namespace OperationCompletion
+
+} // namespace Events
+} // namespace OperationalState
+
+namespace RvcOperationalState {
+namespace Events {
+
+namespace OperationalError {
+static constexpr EventId Id = 0x00000000;
+} // namespace OperationalError
+
+namespace OperationCompletion {
+static constexpr EventId Id = 0x00000001;
+} // namespace OperationCompletion
+
+} // namespace Events
+} // namespace RvcOperationalState
+
+namespace BooleanStateConfiguration {
+namespace Events {
+
+namespace AlarmsStateChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace AlarmsStateChanged
+
+namespace SensorFault {
+static constexpr EventId Id = 0x00000001;
+} // namespace SensorFault
+
+} // namespace Events
+} // namespace BooleanStateConfiguration
+
+namespace ValveConfigurationAndControl {
+namespace Events {
+
+namespace ValveStateChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace ValveStateChanged
+
+namespace ValveFault {
+static constexpr EventId Id = 0x00000001;
+} // namespace ValveFault
+
+} // namespace Events
+} // namespace ValveConfigurationAndControl
+
+namespace ElectricalPowerMeasurement {
+namespace Events {
+
+namespace MeasurementPeriodRanges {
+static constexpr EventId Id = 0x00000000;
+} // namespace MeasurementPeriodRanges
+
+} // namespace Events
+} // namespace ElectricalPowerMeasurement
+
+namespace ElectricalEnergyMeasurement {
+namespace Events {
+
+namespace CumulativeEnergyMeasured {
+static constexpr EventId Id = 0x00000000;
+} // namespace CumulativeEnergyMeasured
+
+namespace PeriodicEnergyMeasured {
+static constexpr EventId Id = 0x00000001;
+} // namespace PeriodicEnergyMeasured
+
+} // namespace Events
+} // namespace ElectricalEnergyMeasurement
+
+namespace WaterHeaterManagement {
+namespace Events {
+
+namespace BoostStarted {
+static constexpr EventId Id = 0x00000000;
+} // namespace BoostStarted
+
+namespace BoostEnded {
+static constexpr EventId Id = 0x00000001;
+} // namespace BoostEnded
+
+} // namespace Events
+} // namespace WaterHeaterManagement
+
+namespace DemandResponseLoadControl {
+namespace Events {
+
+namespace LoadControlEventStatusChange {
+static constexpr EventId Id = 0x00000000;
+} // namespace LoadControlEventStatusChange
+
+} // namespace Events
+} // namespace DemandResponseLoadControl
+
+namespace Messages {
+namespace Events {
+
+namespace MessageQueued {
+static constexpr EventId Id = 0x00000000;
+} // namespace MessageQueued
+
+namespace MessagePresented {
+static constexpr EventId Id = 0x00000001;
+} // namespace MessagePresented
+
+namespace MessageComplete {
+static constexpr EventId Id = 0x00000002;
+} // namespace MessageComplete
+
+} // namespace Events
+} // namespace Messages
+
+namespace DeviceEnergyManagement {
+namespace Events {
+
+namespace PowerAdjustStart {
+static constexpr EventId Id = 0x00000000;
+} // namespace PowerAdjustStart
+
+namespace PowerAdjustEnd {
+static constexpr EventId Id = 0x00000001;
+} // namespace PowerAdjustEnd
+
+namespace Paused {
+static constexpr EventId Id = 0x00000002;
+} // namespace Paused
+
+namespace Resumed {
+static constexpr EventId Id = 0x00000003;
+} // namespace Resumed
+
+} // namespace Events
+} // namespace DeviceEnergyManagement
+
+namespace EnergyEvse {
+namespace Events {
+
+namespace EVConnected {
+static constexpr EventId Id = 0x00000000;
+} // namespace EVConnected
+
+namespace EVNotDetected {
+static constexpr EventId Id = 0x00000001;
+} // namespace EVNotDetected
+
+namespace EnergyTransferStarted {
+static constexpr EventId Id = 0x00000002;
+} // namespace EnergyTransferStarted
+
+namespace EnergyTransferStopped {
+static constexpr EventId Id = 0x00000003;
+} // namespace EnergyTransferStopped
+
+namespace Fault {
+static constexpr EventId Id = 0x00000004;
+} // namespace Fault
+
+namespace Rfid {
+static constexpr EventId Id = 0x00000005;
+} // namespace Rfid
+
+} // namespace Events
+} // namespace EnergyEvse
+
+namespace DoorLock {
+namespace Events {
+
+namespace DoorLockAlarm {
+static constexpr EventId Id = 0x00000000;
+} // namespace DoorLockAlarm
+
+namespace DoorStateChange {
+static constexpr EventId Id = 0x00000001;
+} // namespace DoorStateChange
+
+namespace LockOperation {
+static constexpr EventId Id = 0x00000002;
+} // namespace LockOperation
+
+namespace LockOperationError {
+static constexpr EventId Id = 0x00000003;
+} // namespace LockOperationError
+
+namespace LockUserChange {
+static constexpr EventId Id = 0x00000004;
+} // namespace LockUserChange
+
+} // namespace Events
+} // namespace DoorLock
+
+namespace PumpConfigurationAndControl {
+namespace Events {
+
+namespace SupplyVoltageLow {
+static constexpr EventId Id = 0x00000000;
+} // namespace SupplyVoltageLow
+
+namespace SupplyVoltageHigh {
+static constexpr EventId Id = 0x00000001;
+} // namespace SupplyVoltageHigh
+
+namespace PowerMissingPhase {
+static constexpr EventId Id = 0x00000002;
+} // namespace PowerMissingPhase
+
+namespace SystemPressureLow {
+static constexpr EventId Id = 0x00000003;
+} // namespace SystemPressureLow
+
+namespace SystemPressureHigh {
+static constexpr EventId Id = 0x00000004;
+} // namespace SystemPressureHigh
+
+namespace DryRunning {
+static constexpr EventId Id = 0x00000005;
+} // namespace DryRunning
+
+namespace MotorTemperatureHigh {
+static constexpr EventId Id = 0x00000006;
+} // namespace MotorTemperatureHigh
+
+namespace PumpMotorFatalFailure {
+static constexpr EventId Id = 0x00000007;
+} // namespace PumpMotorFatalFailure
+
+namespace ElectronicTemperatureHigh {
+static constexpr EventId Id = 0x00000008;
+} // namespace ElectronicTemperatureHigh
+
+namespace PumpBlocked {
+static constexpr EventId Id = 0x00000009;
+} // namespace PumpBlocked
+
+namespace SensorFailure {
+static constexpr EventId Id = 0x0000000A;
+} // namespace SensorFailure
+
+namespace ElectronicNonFatalFailure {
+static constexpr EventId Id = 0x0000000B;
+} // namespace ElectronicNonFatalFailure
+
+namespace ElectronicFatalFailure {
+static constexpr EventId Id = 0x0000000C;
+} // namespace ElectronicFatalFailure
+
+namespace GeneralFault {
+static constexpr EventId Id = 0x0000000D;
+} // namespace GeneralFault
+
+namespace Leakage {
+static constexpr EventId Id = 0x0000000E;
+} // namespace Leakage
+
+namespace AirDetection {
+static constexpr EventId Id = 0x0000000F;
+} // namespace AirDetection
+
+namespace TurbineOperation {
+static constexpr EventId Id = 0x00000010;
+} // namespace TurbineOperation
+
+} // namespace Events
+} // namespace PumpConfigurationAndControl
+
+namespace OccupancySensing {
+namespace Events {
+
+namespace OccupancyChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace OccupancyChanged
+
+} // namespace Events
+} // namespace OccupancySensing
+
+namespace TargetNavigator {
+namespace Events {
+
+namespace TargetUpdated {
+static constexpr EventId Id = 0x00000000;
+} // namespace TargetUpdated
+
+} // namespace Events
+} // namespace TargetNavigator
+
+namespace MediaPlayback {
+namespace Events {
+
+namespace StateChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace StateChanged
+
+} // namespace Events
+} // namespace MediaPlayback
+
+namespace AccountLogin {
+namespace Events {
+
+namespace LoggedOut {
+static constexpr EventId Id = 0x00000000;
+} // namespace LoggedOut
+
+} // namespace Events
+} // namespace AccountLogin
+
+namespace ContentControl {
+namespace Events {
+
+namespace RemainingScreenTimeExpired {
+static constexpr EventId Id = 0x00000000;
+} // namespace RemainingScreenTimeExpired
+
+} // namespace Events
+} // namespace ContentControl
+
+namespace ZoneManagement {
+namespace Events {
+
+namespace ZoneTriggered {
+static constexpr EventId Id = 0x00000000;
+} // namespace ZoneTriggered
+
+namespace ZoneStopped {
+static constexpr EventId Id = 0x00000001;
+} // namespace ZoneStopped
+
+} // namespace Events
+} // namespace ZoneManagement
+
+namespace CameraAvStreamManagement {
+namespace Events {
+
+namespace VideoStreamChanged {
+static constexpr EventId Id = 0x00000000;
+} // namespace VideoStreamChanged
+
+namespace AudioStreamChanged {
+static constexpr EventId Id = 0x00000001;
+} // namespace AudioStreamChanged
+
+namespace SnapshotStreamChanged {
+static constexpr EventId Id = 0x00000002;
+} // namespace SnapshotStreamChanged
+
+} // namespace Events
+} // namespace CameraAvStreamManagement
+
+namespace CommissionerControl {
+namespace Events {
+
+namespace CommissioningRequestResult {
+static constexpr EventId Id = 0x00000000;
+} // namespace CommissioningRequestResult
+
+} // namespace Events
+} // namespace CommissionerControl
+
+namespace UnitTesting {
+namespace Events {
+
+namespace TestEvent {
+static constexpr EventId Id = 0x00000001;
+} // namespace TestEvent
+
+namespace TestFabricScopedEvent {
+static constexpr EventId Id = 0x00000002;
+} // namespace TestFabricScopedEvent
+
+namespace TestDifferentVendorMeiEvent {
+static constexpr EventId Id = 0xFFF200EE;
+} // namespace TestDifferentVendorMeiEvent
+
+} // namespace Events
+} // namespace UnitTesting
+
+namespace SampleManufacturerSpecific {
+namespace Events {
+
+namespace PingCountEvent {
+static constexpr EventId Id = 0x00000000;
+} // namespace PingCountEvent
+
+} // namespace Events
+} // namespace SampleManufacturerSpecific
+
+namespace SampleExternalManufacturerSpecific {
+namespace Events {
+
+namespace PingCountEvent {
+static constexpr EventId Id = 0x00000000;
+} // namespace PingCountEvent
+
+} // namespace Events
+} // namespace SampleExternalManufacturerSpecific
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dk_nrf52840.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dk_nrf52840.yml
new file mode 100644
index 00000000000000..ce42b39e55ee87
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dk_nrf52840.yml
@@ -0,0 +1,42 @@
+mcuboot:
+ address: 0x0
+ size: 0x7000
+ region: flash_primary
+mcuboot_pad:
+ address: 0x7000
+ size: 0x200
+app:
+ address: 0x7200
+ size: 0xf3e00
+mcuboot_primary:
+ orig_span: &id001
+ - mcuboot_pad
+ - app
+ span: *id001
+ address: 0x7000
+ size: 0xf4000
+ region: flash_primary
+mcuboot_primary_app:
+ orig_span: &id002
+ - app
+ span: *id002
+ address: 0x7200
+ size: 0xf3e00
+factory_data:
+ address: 0xfb000
+ size: 0x1000
+ region: flash_primary
+settings_storage:
+ address: 0xfc000
+ size: 0x4000
+ region: flash_primary
+mcuboot_secondary:
+ address: 0x0
+ size: 0xf4000
+ device: MX25R64
+ region: external_flash
+external_flash:
+ address: 0xf4000
+ size: 0x70c000
+ device: MX25R64
+ region: external_flash
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dk_nrf52840_release.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dk_nrf52840_release.yml
new file mode 100644
index 00000000000000..ce42b39e55ee87
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dk_nrf52840_release.yml
@@ -0,0 +1,42 @@
+mcuboot:
+ address: 0x0
+ size: 0x7000
+ region: flash_primary
+mcuboot_pad:
+ address: 0x7000
+ size: 0x200
+app:
+ address: 0x7200
+ size: 0xf3e00
+mcuboot_primary:
+ orig_span: &id001
+ - mcuboot_pad
+ - app
+ span: *id001
+ address: 0x7000
+ size: 0xf4000
+ region: flash_primary
+mcuboot_primary_app:
+ orig_span: &id002
+ - app
+ span: *id002
+ address: 0x7200
+ size: 0xf3e00
+factory_data:
+ address: 0xfb000
+ size: 0x1000
+ region: flash_primary
+settings_storage:
+ address: 0xfc000
+ size: 0x4000
+ region: flash_primary
+mcuboot_secondary:
+ address: 0x0
+ size: 0xf4000
+ device: MX25R64
+ region: external_flash
+external_flash:
+ address: 0xf4000
+ size: 0x70c000
+ device: MX25R64
+ region: external_flash
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dongle_nrf52840.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dongle_nrf52840.yml
new file mode 100644
index 00000000000000..ad0f9426169e9d
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf52840dongle_nrf52840.yml
@@ -0,0 +1,8 @@
+settings_storage:
+ address: 0xd8000
+ size: 0x8000
+ region: flash_primary
+open_bootloader:
+ address: 0xe0000
+ size: 0x20000
+ region: flash_primary
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf5340dk_nrf5340_cpuapp.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf5340dk_nrf5340_cpuapp.yml
new file mode 100644
index 00000000000000..10e8680c363a53
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf5340dk_nrf5340_cpuapp.yml
@@ -0,0 +1,56 @@
+mcuboot:
+ address: 0x0
+ size: 0x8000
+ region: flash_primary
+mcuboot_pad:
+ address: 0x8000
+ size: 0x200
+app:
+ address: 0x8200
+ size: 0xf2e00
+mcuboot_primary:
+ orig_span: &id001
+ - mcuboot_pad
+ - app
+ span: *id001
+ address: 0x8000
+ size: 0xf3000
+ region: flash_primary
+mcuboot_primary_app:
+ orig_span: &id002
+ - app
+ span: *id002
+ address: 0x8200
+ size: 0xf2e00
+factory_data:
+ address: 0xfb000
+ size: 0x1000
+ region: flash_primary
+settings_storage:
+ address: 0xfc000
+ size: 0x4000
+ region: flash_primary
+mcuboot_primary_1:
+ address: 0x0
+ size: 0x40000
+ device: flash_ctrl
+ region: ram_flash
+mcuboot_secondary:
+ address: 0x0
+ size: 0xf3000
+ device: MX25R64
+ region: external_flash
+mcuboot_secondary_1:
+ address: 0xf3000
+ size: 0x40000
+ device: MX25R64
+ region: external_flash
+external_flash:
+ address: 0x133000
+ size: 0x6CD000
+ device: MX25R64
+ region: external_flash
+pcd_sram:
+ address: 0x20000000
+ size: 0x2000
+ region: sram_primary
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf5340dk_nrf5340_cpuapp_release.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf5340dk_nrf5340_cpuapp_release.yml
new file mode 100644
index 00000000000000..10e8680c363a53
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf5340dk_nrf5340_cpuapp_release.yml
@@ -0,0 +1,56 @@
+mcuboot:
+ address: 0x0
+ size: 0x8000
+ region: flash_primary
+mcuboot_pad:
+ address: 0x8000
+ size: 0x200
+app:
+ address: 0x8200
+ size: 0xf2e00
+mcuboot_primary:
+ orig_span: &id001
+ - mcuboot_pad
+ - app
+ span: *id001
+ address: 0x8000
+ size: 0xf3000
+ region: flash_primary
+mcuboot_primary_app:
+ orig_span: &id002
+ - app
+ span: *id002
+ address: 0x8200
+ size: 0xf2e00
+factory_data:
+ address: 0xfb000
+ size: 0x1000
+ region: flash_primary
+settings_storage:
+ address: 0xfc000
+ size: 0x4000
+ region: flash_primary
+mcuboot_primary_1:
+ address: 0x0
+ size: 0x40000
+ device: flash_ctrl
+ region: ram_flash
+mcuboot_secondary:
+ address: 0x0
+ size: 0xf3000
+ device: MX25R64
+ region: external_flash
+mcuboot_secondary_1:
+ address: 0xf3000
+ size: 0x40000
+ device: MX25R64
+ region: external_flash
+external_flash:
+ address: 0x133000
+ size: 0x6CD000
+ device: MX25R64
+ region: external_flash
+pcd_sram:
+ address: 0x20000000
+ size: 0x2000
+ region: sram_primary
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf7002dk_nrf5340_cpuapp.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf7002dk_nrf5340_cpuapp.yml
new file mode 100644
index 00000000000000..3c56dc0ddb1968
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf7002dk_nrf5340_cpuapp.yml
@@ -0,0 +1,56 @@
+mcuboot:
+ address: 0x0
+ size: 0xC000
+ region: flash_primary
+mcuboot_pad:
+ address: 0xC000
+ size: 0x200
+app:
+ address: 0xC200
+ size: 0xeee00
+mcuboot_primary:
+ orig_span: &id001
+ - mcuboot_pad
+ - app
+ span: *id001
+ address: 0xC000
+ size: 0xef000
+ region: flash_primary
+mcuboot_primary_app:
+ orig_span: &id002
+ - app
+ span: *id002
+ address: 0xC200
+ size: 0xeee00
+factory_data:
+ address: 0xfb000
+ size: 0x1000
+ region: flash_primary
+settings_storage:
+ address: 0xfc000
+ size: 0x4000
+ region: flash_primary
+mcuboot_primary_1:
+ address: 0x0
+ size: 0x40000
+ device: flash_ctrl
+ region: ram_flash
+mcuboot_secondary:
+ address: 0x0
+ size: 0xef000
+ device: MX25R64
+ region: external_flash
+mcuboot_secondary_1:
+ address: 0xef000
+ size: 0x40000
+ device: MX25R64
+ region: external_flash
+external_flash:
+ address: 0x12f000
+ size: 0x6D1000
+ device: MX25R64
+ region: external_flash
+pcd_sram:
+ address: 0x20000000
+ size: 0x2000
+ region: sram_primary
diff --git a/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf7002dk_nrf5340_cpuapp_release.yml b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf7002dk_nrf5340_cpuapp_release.yml
new file mode 100644
index 00000000000000..3c56dc0ddb1968
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/pm_static_nrf7002dk_nrf5340_cpuapp_release.yml
@@ -0,0 +1,56 @@
+mcuboot:
+ address: 0x0
+ size: 0xC000
+ region: flash_primary
+mcuboot_pad:
+ address: 0xC000
+ size: 0x200
+app:
+ address: 0xC200
+ size: 0xeee00
+mcuboot_primary:
+ orig_span: &id001
+ - mcuboot_pad
+ - app
+ span: *id001
+ address: 0xC000
+ size: 0xef000
+ region: flash_primary
+mcuboot_primary_app:
+ orig_span: &id002
+ - app
+ span: *id002
+ address: 0xC200
+ size: 0xeee00
+factory_data:
+ address: 0xfb000
+ size: 0x1000
+ region: flash_primary
+settings_storage:
+ address: 0xfc000
+ size: 0x4000
+ region: flash_primary
+mcuboot_primary_1:
+ address: 0x0
+ size: 0x40000
+ device: flash_ctrl
+ region: ram_flash
+mcuboot_secondary:
+ address: 0x0
+ size: 0xef000
+ device: MX25R64
+ region: external_flash
+mcuboot_secondary_1:
+ address: 0xef000
+ size: 0x40000
+ device: MX25R64
+ region: external_flash
+external_flash:
+ address: 0x12f000
+ size: 0x6D1000
+ device: MX25R64
+ region: external_flash
+pcd_sram:
+ address: 0x20000000
+ size: 0x2000
+ region: sram_primary
diff --git a/examples/manufacturer-specific-app/nrfconnect/prj.conf b/examples/manufacturer-specific-app/nrfconnect/prj.conf
new file mode 100644
index 00000000000000..43c978d10ee134
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/prj.conf
@@ -0,0 +1,61 @@
+#
+# Copyright (c) 2022 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# This sample uses Kconfig.defaults to set options common for all
+# samples. This file should contain only options specific for this sample
+# or overrides of default values.
+
+# Enable CHIP
+CONFIG_CHIP=y
+CONFIG_CHIP_PROJECT_CONFIG="main/include/CHIPProjectConfig.h"
+CONFIG_CHIP_PROJECT_APP_COMMON_INCLUDE_DIRS="manufacturer-specific/zzz_generated/app-common"
+
+# 32773 == 0x8005 (example lighting-app)
+CONFIG_CHIP_DEVICE_PRODUCT_ID=32773
+CONFIG_STD_CPP17=y
+
+# Enable Matter pairing automatically on application start.
+CONFIG_CHIP_ENABLE_PAIRING_AUTOSTART=y
+
+# Enable Matter extended announcement and increase duration to 1 hour.
+CONFIG_CHIP_BLE_EXT_ADVERTISING=y
+CONFIG_CHIP_BLE_ADVERTISING_DURATION=60
+
+# Add support for LEDs and buttons on Nordic development kits
+CONFIG_DK_LIBRARY=y
+CONFIG_PWM=y
+
+# General networking settings
+CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT=14
+
+
+# Bluetooth Low Energy configuration
+CONFIG_BT_DEVICE_NAME="MatterLight"
+
+# Stack size settings
+CONFIG_IEEE802154_NRF5_RX_STACK_SIZE=1024
+
+# Other settings
+CONFIG_THREAD_NAME=y
+CONFIG_MPU_STACK_GUARD=y
+CONFIG_RESET_ON_FATAL_ERROR=n
+
+# Reduce application size
+CONFIG_USE_SEGGER_RTT=n
+
+# Enable Factory Data feature
+CONFIG_CHIP_FACTORY_DATA=y
+CONFIG_CHIP_FACTORY_DATA_BUILD=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/prj_release.conf b/examples/manufacturer-specific-app/nrfconnect/prj_release.conf
new file mode 100644
index 00000000000000..b801605e970a03
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/prj_release.conf
@@ -0,0 +1,70 @@
+#
+# Copyright (c) 2022 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# This sample uses Kconfig.defaults to set options common for all
+# samples. This file should contain only options specific for this sample
+# or overrides of default values.
+
+# Enable CHIP
+CONFIG_CHIP=y
+CONFIG_CHIP_PROJECT_CONFIG="main/include/CHIPProjectConfig.h"
+CONFIG_CHIP_PROJECT_APP_COMMON_INCLUDE_DIRS="manufacturer-specific/zzz_generated/app-common"
+
+# 32773 == 0x8005 (example lighting-app)
+CONFIG_CHIP_DEVICE_PRODUCT_ID=32773
+CONFIG_STD_CPP17=y
+
+# Enable Matter pairing automatically on application start.
+CONFIG_CHIP_ENABLE_PAIRING_AUTOSTART=y
+
+# Enable Matter extended announcement and increase duration to 1 hour.
+CONFIG_CHIP_BLE_EXT_ADVERTISING=y
+CONFIG_CHIP_BLE_ADVERTISING_DURATION=60
+
+# Add support for LEDs and buttons on Nordic development kits
+CONFIG_DK_LIBRARY=y
+CONFIG_PWM=y
+
+# General networking settings
+CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT=14
+
+# Bluetooth Low Energy configuration
+CONFIG_BT_DEVICE_NAME="MatterLight"
+
+# Enable system reset on fatal error
+CONFIG_RESET_ON_FATAL_ERROR=y
+
+# Stack size settings
+CONFIG_IEEE802154_NRF5_RX_STACK_SIZE=1024
+
+# Disable all debug features
+CONFIG_USE_SEGGER_RTT=n
+CONFIG_SHELL=n
+CONFIG_OPENTHREAD_SHELL=n
+CONFIG_CONSOLE=n
+CONFIG_UART_CONSOLE=n
+CONFIG_SERIAL=n
+CONFIG_LOG=n
+CONFIG_LOG_MODE_MINIMAL=n
+CONFIG_ASSERT_VERBOSE=n
+CONFIG_ASSERT_NO_FILE_INFO=y
+CONFIG_PRINTK=n
+CONFIG_PRINTK_SYNC=n
+CONFIG_BOOT_BANNER=n
+
+# Enable Factory Data feature
+CONFIG_CHIP_FACTORY_DATA=y
+CONFIG_CHIP_FACTORY_DATA_BUILD=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/rpc.overlay b/examples/manufacturer-specific-app/nrfconnect/rpc.overlay
new file mode 100644
index 00000000000000..315349a69555e2
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/rpc.overlay
@@ -0,0 +1,51 @@
+#
+# Copyright (c) 2020 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# This file should be used as a configuration overlay to build Pigweed RPCs to
+# lighting-app.
+
+# Enable Pigweed RPC
+CONFIG_CHIP_PW_RPC=y
+
+# Add support for C++17 to build Pigweed components
+CONFIG_STD_CPP14=n
+CONFIG_STD_CPP17=y
+
+# Add support for Zephyr console component to use it for Pigweed console purposes
+CONFIG_CONSOLE_SUBSYS=y
+CONFIG_CONSOLE_GETCHAR=y
+CONFIG_CONSOLE_PUTCHAR_BUFSIZE=256
+
+# Disable features which may interfere with Pigweed HDLC transport
+CONFIG_SHELL=n
+CONFIG_OPENTHREAD_SHELL=n
+CONFIG_BOOT_BANNER=n
+
+# Configure Zephyr logger with defaults backends disabled as the app provides its own,
+# based on Pigweed HDLC.
+CONFIG_LOG=y
+CONFIG_LOG_MODE_MINIMAL=n
+CONFIG_LOG_MODE_IMMEDIATE=y
+CONFIG_LOG_BACKEND_UART=n
+CONFIG_LOG_BACKEND_RTT=n
+CONFIG_LOG_OUTPUT=y
+
+# Increase zephyr tty rx buffer
+CONFIG_CONSOLE_GETCHAR_BUFSIZE=128
+
+# Increase BLE thread stack size
+CONFIG_BT_RX_STACK_SIZE=2048
+
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild.conf
new file mode 100644
index 00000000000000..d0c5eee2b93c39
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild.conf
@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+SB_CONFIG_MATTER=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/boards/nrf5340dk_nrf5340_cpunet.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/boards/nrf5340dk_nrf5340_cpunet.conf
new file mode 100644
index 00000000000000..8540585e53358b
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/boards/nrf5340dk_nrf5340_cpunet.conf
@@ -0,0 +1,58 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Disable serial and UART interface.
+CONFIG_SERIAL=n
+CONFIG_UART_CONSOLE=n
+CONFIG_LOG=n
+
+# RAM usage configuration
+CONFIG_HEAP_MEM_POOL_SIZE=8192
+CONFIG_MAIN_STACK_SIZE=2048
+CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048
+
+# BT configuration
+CONFIG_BT=y
+CONFIG_BT_HCI_RAW=y
+CONFIG_BT_MAX_CONN=1
+CONFIG_BT_CTLR_ASSERT_HANDLER=y
+CONFIG_BT_PERIPHERAL=y
+CONFIG_BT_CENTRAL=n
+CONFIG_BT_BUF_ACL_RX_SIZE=502
+CONFIG_BT_BUF_ACL_TX_SIZE=251
+CONFIG_BT_CTLR_DATA_LENGTH_MAX=251
+CONFIG_BT_CTLR_PHY_2M=n
+
+# 802.15.4 configuration
+CONFIG_NRF_802154_SER_RADIO=y
+CONFIG_NRF_802154_ENCRYPTION=y
+CONFIG_NRF_RTC_TIMER_USER_CHAN_COUNT=2
+
+# Debug and assert configuration
+CONFIG_ASSERT=y
+CONFIG_DEBUG_INFO=y
+CONFIG_EXCEPTION_STACK_TRACE=y
+CONFIG_RESET_ON_FATAL_ERROR=n
+CONFIG_REBOOT=n
+
+# IPC
+CONFIG_MBOX=y
+CONFIG_IPC_SERVICE=y
+
+# ipc_radio
+CONFIG_IPC_RADIO_BT=y
+CONFIG_IPC_RADIO_BT_HCI_IPC=y
+CONFIG_IPC_RADIO_802154=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/boards/nrf7002dk_nrf5340_cpunet.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/boards/nrf7002dk_nrf5340_cpunet.conf
new file mode 100644
index 00000000000000..694c3b08242f29
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/boards/nrf7002dk_nrf5340_cpunet.conf
@@ -0,0 +1,52 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Disable serial and UART interface.
+CONFIG_SERIAL=n
+CONFIG_UART_CONSOLE=n
+CONFIG_LOG=n
+
+# RAM usage configuration
+CONFIG_HEAP_MEM_POOL_SIZE=8192
+CONFIG_MAIN_STACK_SIZE=2048
+CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048
+
+# BT configuration
+CONFIG_BT=y
+CONFIG_BT_HCI_RAW=y
+CONFIG_BT_MAX_CONN=1
+CONFIG_BT_CTLR_ASSERT_HANDLER=y
+CONFIG_BT_PERIPHERAL=y
+CONFIG_BT_CENTRAL=n
+CONFIG_BT_BUF_ACL_RX_SIZE=502
+CONFIG_BT_BUF_ACL_TX_SIZE=251
+CONFIG_BT_CTLR_DATA_LENGTH_MAX=251
+CONFIG_BT_CTLR_PHY_2M=n
+
+# Debug and assert configuration
+CONFIG_ASSERT=y
+CONFIG_DEBUG_INFO=y
+CONFIG_EXCEPTION_STACK_TRACE=y
+CONFIG_RESET_ON_FATAL_ERROR=n
+CONFIG_REBOOT=n
+
+# IPC
+CONFIG_MBOX=y
+CONFIG_IPC_SERVICE=y
+
+# ipc_radio
+CONFIG_IPC_RADIO_BT=y
+CONFIG_IPC_RADIO_BT_HCI_IPC=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/prj.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/prj.conf
new file mode 100644
index 00000000000000..8906415dda4fc7
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/prj.conf
@@ -0,0 +1,21 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+CONFIG_SERIAL=n
+CONFIG_UART_CONSOLE=n
+CONFIG_LOG=n
+
+CONFIG_RESET_ON_FATAL_ERROR=n
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/prj_release.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/prj_release.conf
new file mode 100644
index 00000000000000..7f92a51630cce0
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/ipc_radio/prj_release.conf
@@ -0,0 +1,20 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+CONFIG_SERIAL=n
+CONFIG_UART_CONSOLE=n
+CONFIG_LOG=n
+
+CONFIG_RESET_ON_FATAL_ERROR=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/app.overlay b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/app.overlay
new file mode 100644
index 00000000000000..74d3dfbfd22f30
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/app.overlay
@@ -0,0 +1,5 @@
+/ {
+ chosen {
+ zephyr,code-partition = &boot_partition;
+ };
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf52840dk_nrf52840.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf52840dk_nrf52840.conf
new file mode 100644
index 00000000000000..50610217c762b5
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf52840dk_nrf52840.conf
@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+CONFIG_NORDIC_QSPI_NOR=y
+CONFIG_NORDIC_QSPI_NOR_FLASH_LAYOUT_PAGE_SIZE=4096
+CONFIG_NORDIC_QSPI_NOR_STACK_WRITE_BUFFER_SIZE=16
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf52840dk_nrf52840.overlay b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf52840dk_nrf52840.overlay
new file mode 100644
index 00000000000000..054f04712058a3
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf52840dk_nrf52840.overlay
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/ {
+ chosen {
+ zephyr,code-partition = &boot_partition;
+ nordic,pm-ext-flash = &mx25r64;
+ };
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf5340dk_nrf5340_cpuapp.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf5340dk_nrf5340_cpuapp.conf
new file mode 100644
index 00000000000000..2d86fe6442dd39
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf5340dk_nrf5340_cpuapp.conf
@@ -0,0 +1,35 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+CONFIG_NORDIC_QSPI_NOR=y
+CONFIG_NORDIC_QSPI_NOR_FLASH_LAYOUT_PAGE_SIZE=4096
+CONFIG_NORDIC_QSPI_NOR_STACK_WRITE_BUFFER_SIZE=16
+
+# The following configurations are required to support simultaneous multi image update
+CONFIG_PCD_APP=y
+CONFIG_UPDATEABLE_IMAGE_NUMBER=2
+
+CONFIG_BOOT_SWAP_USING_MOVE=n
+# Multi-image updates do not support image swapping yet.
+CONFIG_BOOT_UPGRADE_ONLY=y
+
+# The network core cannot access external flash directly. The flash simulator must be used to
+# provide a memory region that is used to forward the new firmware to the network core.
+CONFIG_FLASH_SIMULATOR=y
+CONFIG_FLASH_SIMULATOR_DOUBLE_WRITES=y
+CONFIG_FLASH_SIMULATOR_STATS=n
+
+CONFIG_ZCBOR=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf5340dk_nrf5340_cpuapp.overlay b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf5340dk_nrf5340_cpuapp.overlay
new file mode 100644
index 00000000000000..054f04712058a3
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf5340dk_nrf5340_cpuapp.overlay
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/ {
+ chosen {
+ zephyr,code-partition = &boot_partition;
+ nordic,pm-ext-flash = &mx25r64;
+ };
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf7002dk_nrf5340_cpuapp.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf7002dk_nrf5340_cpuapp.conf
new file mode 100644
index 00000000000000..81701b7eb63f70
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf7002dk_nrf5340_cpuapp.conf
@@ -0,0 +1,40 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# nRF7002DK uses SPI NOR external flash
+CONFIG_GPIO=y
+CONFIG_SPI=y
+CONFIG_SPI_NOR=y
+CONFIG_SPI_NOR_SFDP_DEVICETREE=y
+CONFIG_SPI_NOR_FLASH_LAYOUT_PAGE_SIZE=4096
+
+CONFIG_MULTITHREADING=y
+CONFIG_PM_OVERRIDE_EXTERNAL_DRIVER_CHECK=y
+
+# The following configurations are required to support simultaneous multi image update
+CONFIG_PCD_APP=y
+CONFIG_UPDATEABLE_IMAGE_NUMBER=2
+
+# Multi-image updates do not support image swapping yet.
+CONFIG_BOOT_UPGRADE_ONLY=y
+
+# The network core cannot access external flash directly. The flash simulator must be used to
+# provide a memory region that is used to forward the new firmware to the network core.
+CONFIG_FLASH_SIMULATOR=y
+CONFIG_FLASH_SIMULATOR_DOUBLE_WRITES=y
+CONFIG_FLASH_SIMULATOR_STATS=n
+
+CONFIG_ZCBOR=y
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf7002dk_nrf5340_cpuapp.overlay b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf7002dk_nrf5340_cpuapp.overlay
new file mode 100644
index 00000000000000..054f04712058a3
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/boards/nrf7002dk_nrf5340_cpuapp.overlay
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/ {
+ chosen {
+ zephyr,code-partition = &boot_partition;
+ nordic,pm-ext-flash = &mx25r64;
+ };
+};
diff --git a/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/prj.conf b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/prj.conf
new file mode 100644
index 00000000000000..3bcb12fe7b8d25
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/sysbuild/mcuboot/prj.conf
@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+CONFIG_MAIN_STACK_SIZE=10240
+
+CONFIG_BOOT_SWAP_SAVE_ENCTLV=n
+CONFIG_BOOT_BOOTSTRAP=n
+CONFIG_PM=n
+
+CONFIG_FLASH=y
+CONFIG_FPROTECT=y
+
+CONFIG_MBEDTLS_CFG_FILE="mcuboot-mbedtls-cfg.h"
+
+# Use minimal C library instead of the Picolib
+CONFIG_MINIMAL_LIBC=y
+
+# Bootloader size optimization
+CONFIG_CONSOLE=n
+CONFIG_SERIAL=n
+CONFIG_UART_CONSOLE=n
+CONFIG_USE_SEGGER_RTT=n
+CONFIG_GPIO=n
+
+CONFIG_BOOT_MAX_IMG_SECTORS=256
+
+CONFIG_LOG=n
+CONFIG_CONSOLE_HANDLER=n
+CONFIG_BOOT_BANNER=n
+CONFIG_NCS_BOOT_BANNER=n
+CONFIG_TIMESLICING=n
+CONFIG_RESET_ON_FATAL_ERROR=n
+CONFIG_MULTITHREADING=n
+CONFIG_TICKLESS_KERNEL=n
+CONFIG_TIMEOUT_64BIT=n
+CONFIG_NRF_ENABLE_ICACHE=n
diff --git a/examples/manufacturer-specific-app/nrfconnect/third_party/connectedhomeip b/examples/manufacturer-specific-app/nrfconnect/third_party/connectedhomeip
new file mode 120000
index 00000000000000..c866b86874994d
--- /dev/null
+++ b/examples/manufacturer-specific-app/nrfconnect/third_party/connectedhomeip
@@ -0,0 +1 @@
+../../../..
\ No newline at end of file
diff --git a/scripts/rules.matterlint b/scripts/rules.matterlint
index 4be932fffa2ccd..05d3f60c4d88ef 100644
--- a/scripts/rules.matterlint
+++ b/scripts/rules.matterlint
@@ -119,7 +119,7 @@ load "../src/app/zap-templates/zcl/data-model/chip/temperature-control-cluster.x
load "../src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml";
load "../src/app/zap-templates/zcl/data-model/chip/air-quality-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/resource-monitoring-cluster.xml";
-load "../src/app/zap-templates/zcl/data-model/chip/sample-mei-cluster.xml";
+load "../src/app/zap-templates/zcl/data-model/chip/sample-manufacturer-specific-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/electrical-energy-measurement-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/electrical-power-measurement-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/zone-management-cluster.xml";
diff --git a/src/app/chip_data_model.cmake b/src/app/chip_data_model.cmake
index dcafc0055de3e9..9a6100fa80d7cb 100644
--- a/src/app/chip_data_model.cmake
+++ b/src/app/chip_data_model.cmake
@@ -67,10 +67,12 @@ endfunction()
# EXTERNAL_CLUSTERS Clusters with external implementations. The default implementations
# will not be used nor required for these clusters.
# Format: MY_CUSTOM_CLUSTER'.
+# TEMPLATES_JSON Use external templates.json (because of out-of-tree manufacturer
+# specific clusters, which need to be configured via an out-of-tree config-data.yaml)
#
function(chip_configure_data_model APP_TARGET)
set(SCOPE PRIVATE)
- cmake_parse_arguments(ARG "" "SCOPE;ZAP_FILE;IDL" "EXTERNAL_CLUSTERS" ${ARGN})
+ cmake_parse_arguments(ARG "" "SCOPE;ZAP_FILE;IDL;TEMPLATES_JSON" "EXTERNAL_CLUSTERS;EXTERNAL_APP_COMMON" ${ARGN})
if(ARG_SCOPE)
set(SCOPE ${ARG_SCOPE})
@@ -133,17 +135,10 @@ function(chip_configure_data_model APP_TARGET)
${CHIP_APP_BASE_DIR}/icd/server/ICDConfigurationData.cpp
)
- # This is:
- # //src/app/common:cluster-objects
- #
- # TODO: ideally we would avoid duplication and would link gn-built items
- target_sources(${APP_TARGET} ${SCOPE}
- ${CHIP_APP_BASE_DIR}/../../zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
- )
-
chip_zapgen(${APP_TARGET}-zapgen
INPUT "${ARG_ZAP_FILE}"
GENERATOR "app-templates"
+ TEMPLATES_JSON ${ARG_TEMPLATES_JSON}
OUTPUTS
"zap-generated/access.h"
"zap-generated/endpoint_config.h"
@@ -156,7 +151,6 @@ function(chip_configure_data_model APP_TARGET)
add_dependencies(${APP_TARGET} ${APP_TARGET}-zapgen)
target_sources(${APP_TARGET} ${SCOPE}
- ${CHIP_APP_BASE_DIR}/../../zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
${CHIP_APP_BASE_DIR}/reporting/reporting.cpp
${CHIP_APP_BASE_DIR}/util/attribute-storage.cpp
${CHIP_APP_BASE_DIR}/util/attribute-table.cpp
@@ -173,4 +167,19 @@ function(chip_configure_data_model APP_TARGET)
${APP_GEN_FILES}
${APP_TEMPLATES_GEN_FILES}
)
+
+ if(ARG_EXTERNAL_APP_COMMON)
+ target_sources(${APP_TARGET} ${SCOPE}
+ ${ARG_EXTERNAL_APP_COMMON}/app-common/zap-generated/attributes/Accessors.cpp
+ # TODO: ideally we would avoid duplication and would link gn-built items
+ ${ARG_EXTERNAL_APP_COMMON}/app-common/zap-generated/cluster-objects.cpp
+ )
+ else()
+ target_sources(${APP_TARGET} ${SCOPE}
+ ${CHIP_APP_BASE_DIR}/../../zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
+ # TODO: ideally we would avoid duplication and would link gn-built items
+ ${CHIP_APP_BASE_DIR}/../../zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
+ )
+ endif()
+
endfunction()
diff --git a/src/app/chip_data_model.gni b/src/app/chip_data_model.gni
index 02be8ebaccf05b..70dc4cdb17d84a 100644
--- a/src/app/chip_data_model.gni
+++ b/src/app/chip_data_model.gni
@@ -199,8 +199,14 @@ template("chip_data_model") {
"${_app_root}/util/binding-table.h",
"${_app_root}/util/generic-callback-stubs.cpp",
"${_app_root}/util/privilege-storage.cpp",
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp",
]
+
+ if (defined(external_app_common)) {
+ sources += [ "${external_app_common}/app-common/zap-generated/attributes/Accessors.cpp" ]
+ } else {
+ sources += [ "${chip_root}/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp" ]
+ }
+
sources += codegen_data_model_SOURCES
if (!chip_build_controller_dynamic_server) {
diff --git a/src/app/clusters/sample-mei-server/sample-mei-server.cpp b/src/app/clusters/manufacturer-specific-server/manufacturer-specific-server.cpp
similarity index 69%
rename from src/app/clusters/sample-mei-server/sample-mei-server.cpp
rename to src/app/clusters/manufacturer-specific-server/manufacturer-specific-server.cpp
index 7677e3b1035cc7..1569e4a2d7dd3a 100644
--- a/src/app/clusters/sample-mei-server/sample-mei-server.cpp
+++ b/src/app/clusters/manufacturer-specific-server/manufacturer-specific-server.cpp
@@ -1,4 +1,4 @@
-#include "sample-mei-server.h"
+#include "sample-manufacturer-specific-server.h"
#include <app-common/zap-generated/attributes/Accessors.h>
#include <app-common/zap-generated/cluster-objects.h>
@@ -19,46 +19,49 @@
using namespace chip;
using namespace chip::app;
using namespace chip::app::Clusters;
-using namespace chip::app::Clusters::SampleMei;
-using namespace chip::app::Clusters::SampleMei::Commands;
-using namespace chip::app::Clusters::SampleMei::Attributes;
+using namespace chip::app::Clusters::SampleManufacturerSpecific;
+using namespace chip::app::Clusters::SampleManufacturerSpecific::Commands;
+using namespace chip::app::Clusters::SampleManufacturerSpecific::Attributes;
// *****************************************************************************
// Init/Shutdown Callbacks
-void MatterSampleMeiPluginServerInitCallback()
+void MatterSampleManufacturerSpecificPluginServerInitCallback()
{
- ChipLogProgress(Zcl, "Sample MEI Init. Ep %d, Total Ep %u", MATTER_DM_SAMPLE_MEI_CLUSTER_SERVER_ENDPOINT_COUNT,
+ ChipLogProgress(Zcl, "Sample Manufacturer Specific Init. Ep %d, Total Ep %u",
+ MATTER_DM_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_ENDPOINT_COUNT,
static_cast<uint16_t>(kNumSupportedEndpoints));
- ReturnOnFailure(CommandHandlerInterfaceRegistry::Instance().RegisterCommandHandler(&SampleMeiServer::Instance()));
- VerifyOrReturn(AttributeAccessInterfaceRegistry::Instance().Register(&SampleMeiServer::Instance()), CHIP_ERROR_INCORRECT_STATE);
+ ReturnOnFailure(
+ CommandHandlerInterfaceRegistry::Instance().RegisterCommandHandler(&SampleManufacturerSpecificServer::Instance()));
+ VerifyOrReturn(AttributeAccessInterfaceRegistry::Instance().Register(&SampleManufacturerSpecificServer::Instance()),
+ CHIP_ERROR_INCORRECT_STATE);
}
-void emberAfSampleMeiClusterServerInitCallback(chip::EndpointId endpoint)
+void emberAfSampleManufacturerSpecificClusterServerInitCallback(chip::EndpointId endpoint)
{
- ChipLogProgress(Zcl, "Creating Sample MEI cluster, Ep %d", endpoint);
- SampleMeiServer::Instance().RegisterEndpoint(endpoint);
+ ChipLogProgress(Zcl, "Creating Sample Manufacturer Specific cluster, Ep %d", endpoint);
+ SampleManufacturerSpecificServer::Instance().RegisterEndpoint(endpoint);
}
-void MatterSampleMeiClusterServerShutdownCallback(chip::EndpointId endpoint)
+void MatterSampleManufacturerSpecificClusterServerShutdownCallback(chip::EndpointId endpoint)
{
// There's currently no whole-cluster shutdown callback. That would trigger
// call to `Shutdown`. Thus ep-based shutdown calls `UnregisterEndpoint`
- ChipLogProgress(Zcl, "Shutting down Sample MEI cluster, Ep %d", endpoint);
- SampleMeiServer::Instance().UnregisterEndpoint(endpoint);
+ ChipLogProgress(Zcl, "Shutting down Sample Manufacturer Specific cluster, Ep %d", endpoint);
+ SampleManufacturerSpecificServer::Instance().UnregisterEndpoint(endpoint);
}
// *****************************************************************************
-// SampleMeiContent
+// SampleManufacturerSpecificContent
namespace chip {
namespace app {
namespace Clusters {
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
-SampleMeiContent::SampleMeiContent() : SampleMeiContent(kInvalidEndpointId) {}
+SampleManufacturerSpecificContent::SampleManufacturerSpecificContent() : SampleManufacturerSpecificContent(kInvalidEndpointId) {}
-SampleMeiContent::SampleMeiContent(EndpointId aEndpoint)
+SampleManufacturerSpecificContent::SampleManufacturerSpecificContent(EndpointId aEndpoint)
{
endpoint = aEndpoint;
pingCount = 10000;
@@ -68,9 +71,9 @@ SampleMeiContent::SampleMeiContent(EndpointId aEndpoint)
}
// *****************************************************************************
-// SampleMeiServer
+// SampleManufacturerSpecificServer
-void SampleMeiServer::InvokeCommand(HandlerContext & ctxt)
+void SampleManufacturerSpecificServer::InvokeCommand(HandlerContext & ctxt)
{
auto endpoint = ctxt.mRequestPath.mEndpointId;
auto fabricIndex = ctxt.mCommandHandler.GetAccessingFabricIndex();
@@ -115,7 +118,7 @@ void SampleMeiServer::InvokeCommand(HandlerContext & ctxt)
}
}
-CHIP_ERROR SampleMeiServer::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
+CHIP_ERROR SampleManufacturerSpecificServer::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
{
CHIP_ERROR err = CHIP_NO_ERROR;
auto endpoint = aPath.mEndpointId;
@@ -139,7 +142,7 @@ CHIP_ERROR SampleMeiServer::Read(const ConcreteReadAttributePath & aPath, Attrib
return err;
}
-CHIP_ERROR SampleMeiServer::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder)
+CHIP_ERROR SampleManufacturerSpecificServer::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder)
{
CHIP_ERROR err = CHIP_NO_ERROR;
auto endpoint = aPath.mEndpointId;
@@ -165,13 +168,13 @@ CHIP_ERROR SampleMeiServer::Write(const ConcreteDataAttributePath & aPath, Attri
return err;
}
-SampleMeiServer & SampleMeiServer::Instance()
+SampleManufacturerSpecificServer & SampleManufacturerSpecificServer::Instance()
{
- static SampleMeiServer sampleMeiServer;
- return sampleMeiServer;
+ static SampleManufacturerSpecificServer SampleManufacturerSpecificServer;
+ return SampleManufacturerSpecificServer;
}
-void SampleMeiServer::Shutdown()
+void SampleManufacturerSpecificServer::Shutdown()
{
for (size_t i = 0; i < kNumSupportedEndpoints; ++i)
{
@@ -179,12 +182,12 @@ void SampleMeiServer::Shutdown()
}
}
-size_t SampleMeiServer::GetNumSupportedEndpoints() const
+size_t SampleManufacturerSpecificServer::GetNumSupportedEndpoints() const
{
return kNumSupportedEndpoints;
}
-CHIP_ERROR SampleMeiServer::RegisterEndpoint(EndpointId endpointId)
+CHIP_ERROR SampleManufacturerSpecificServer::RegisterEndpoint(EndpointId endpointId)
{
size_t endpointIndex = NextEmptyIndex();
if (endpointIndex == std::numeric_limits<size_t>::max())
@@ -192,11 +195,11 @@ CHIP_ERROR SampleMeiServer::RegisterEndpoint(EndpointId endpointId)
return CHIP_ERROR_NO_MEMORY;
}
- content[endpointIndex] = SampleMeiContent(endpointId);
+ content[endpointIndex] = SampleManufacturerSpecificContent(endpointId);
return CHIP_NO_ERROR;
}
-CHIP_ERROR SampleMeiServer::UnregisterEndpoint(EndpointId endpointId)
+CHIP_ERROR SampleManufacturerSpecificServer::UnregisterEndpoint(EndpointId endpointId)
{
size_t endpointIndex = EndpointIndex(endpointId);
if (endpointIndex == std::numeric_limits<size_t>::max())
@@ -208,7 +211,7 @@ CHIP_ERROR SampleMeiServer::UnregisterEndpoint(EndpointId endpointId)
return CHIP_NO_ERROR;
}
-size_t SampleMeiServer::EndpointIndex(EndpointId endpointId) const
+size_t SampleManufacturerSpecificServer::EndpointIndex(EndpointId endpointId) const
{
for (size_t i = 0; i < kNumSupportedEndpoints; ++i)
{
@@ -220,7 +223,7 @@ size_t SampleMeiServer::EndpointIndex(EndpointId endpointId) const
return std::numeric_limits<size_t>::max();
}
-size_t SampleMeiServer::NextEmptyIndex() const
+size_t SampleManufacturerSpecificServer::NextEmptyIndex() const
{
for (size_t i = 0; i < kNumSupportedEndpoints; ++i)
{
@@ -232,7 +235,7 @@ size_t SampleMeiServer::NextEmptyIndex() const
return std::numeric_limits<size_t>::max();
}
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
} // namespace chip
diff --git a/src/app/clusters/sample-mei-server/sample-mei-server.h b/src/app/clusters/manufacturer-specific-server/manufacturer-specific-server.h
similarity index 53%
rename from src/app/clusters/sample-mei-server/sample-mei-server.h
rename to src/app/clusters/manufacturer-specific-server/manufacturer-specific-server.h
index 14446ba6f38f02..c9ee944255160a 100644
--- a/src/app/clusters/sample-mei-server/sample-mei-server.h
+++ b/src/app/clusters/manufacturer-specific-server/manufacturer-specific-server.h
@@ -1,5 +1,5 @@
-#ifndef SRC_APP_CLUSTERS_SAMPLE_MEI_CLUSTER_SERVER_SERVER_H_
-#define SRC_APP_CLUSTERS_SAMPLE_MEI_CLUSTER_SERVER_SERVER_H_
+#ifndef SRC_APP_CLUSTERS_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_SERVER_H_
+#define SRC_APP_CLUSTERS_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_SERVER_H_
#include <app-common/zap-generated/cluster-objects.h>
#include <app/AttributeAccessInterface.h>
@@ -11,24 +11,24 @@
#include <lib/support/Span.h>
#include <platform/CHIPDeviceConfig.h>
-#ifdef ZCL_USING_SAMPLE_MEI_CLUSTER_SERVER
-#define SAMPLE_MEI_NUM_SUPPORTED_ENDPOINTS \
- (MATTER_DM_SAMPLE_MEI_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT)
+#ifdef ZCL_USING_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER
+#define SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS \
+ (MATTER_DM_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT)
#else
-#define SAMPLE_MEI_NUM_SUPPORTED_ENDPOINTS CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT
-#endif /* ZCL_USING_SAMPLE_MEI_CLUSTER_SERVER */
-static constexpr size_t kNumSupportedEndpoints = SAMPLE_MEI_NUM_SUPPORTED_ENDPOINTS;
+#define SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT
+#endif /* ZCL_USING_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER */
+static constexpr size_t kNumSupportedEndpoints = SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS;
namespace chip {
namespace app {
namespace Clusters {
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
// *****************************************************************************
-// SampleMeiContent has the stateful attributes of the cluster: its endpoint
+// SampleManufacturerSpecificContent has the stateful attributes of the cluster: its endpoint
// and attributes
-class SampleMeiContent
+class SampleManufacturerSpecificContent
{
public:
EndpointId endpoint;
@@ -37,22 +37,22 @@ class SampleMeiContent
// Attribute List
bool flipflop; /* Attributes::FlipFlop::Id */
- SampleMeiContent(EndpointId endpoint);
- SampleMeiContent();
+ SampleManufacturerSpecificContent(EndpointId endpoint);
+ SampleManufacturerSpecificContent();
};
// *****************************************************************************
-// SampleMeiServer implements both Attributes and Commands
+// SampleManufacturerSpecificServer implements both Attributes and Commands
-class SampleMeiServer : public AttributeAccessInterface, public CommandHandlerInterface
+class SampleManufacturerSpecificServer : public AttributeAccessInterface, public CommandHandlerInterface
{
public:
// Register on all endpoints.
- SampleMeiServer() :
- AttributeAccessInterface(Optional<EndpointId>::Missing(), SampleMei::Id),
+ SampleManufacturerSpecificServer() :
+ AttributeAccessInterface(Optional<EndpointId>::Missing(), SampleManufacturerSpecific::Id),
CommandHandlerInterface(Optional<EndpointId>(), Id)
{}
- static SampleMeiServer & Instance();
+ static SampleManufacturerSpecificServer & Instance();
// Currently not used, but should be called from a whole-cluster shutdown
// callback once cluster lifecycle is clearer
@@ -66,10 +66,10 @@ class SampleMeiServer : public AttributeAccessInterface, public CommandHandlerIn
void InvokeCommand(HandlerContext & ctx) override;
// Attribute storage
-#if SAMPLE_MEI_NUM_SUPPORTED_ENDPOINTS > 0
- SampleMeiContent content[kNumSupportedEndpoints];
+#if SAMPLE_MANUFACTURER_SPECIFIC_NUM_SUPPORTED_ENDPOINTS > 0
+ SampleManufacturerSpecificContent content[kNumSupportedEndpoints];
#else
- SampleMeiContent * content = nullptr;
+ SampleManufacturerSpecificContent * content = nullptr;
#endif
size_t GetNumSupportedEndpoints() const;
@@ -82,9 +82,9 @@ class SampleMeiServer : public AttributeAccessInterface, public CommandHandlerIn
size_t NextEmptyIndex() const;
};
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
} // namespace chip
-#endif // SRC_APP_CLUSTERS_SAMPLE_MEI_CLUSTER_SERVER_SERVER_H_
+#endif // SRC_APP_CLUSTERS_SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_SERVER_SERVER_H_
diff --git a/src/app/common/BUILD.gn b/src/app/common/BUILD.gn
index 36022674cc053a..cc6b50e850c8f5 100644
--- a/src/app/common/BUILD.gn
+++ b/src/app/common/BUILD.gn
@@ -14,22 +14,27 @@
import("//build_overrides/chip.gni")
+declare_args() {
+ # Extra include dir for app-common.
+ chip_project_app_common_include_dir = "${chip_root}/zzz_generated/app-common"
+}
+
config("includes") {
- include_dirs = [ "${chip_root}/zzz_generated/app-common" ]
+ include_dirs = [ chip_project_app_common_include_dir ]
}
source_set("attribute-type") {
- sources = [ "${chip_root}/zzz_generated/app-common/app-common/zap-generated/attribute-type.h" ]
+ sources = [ "${chip_project_app_common_include_dir}/app-common/zap-generated/attribute-type.h" ]
public_configs = [ ":includes" ]
}
source_set("ids") {
sources = [
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h",
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h",
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h",
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/ids/Events.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/ids/Attributes.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/ids/Clusters.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/ids/Commands.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/ids/Events.h",
]
public_deps = [ "${chip_root}/src/app/util:types" ]
@@ -41,8 +46,8 @@ static_library("cluster-objects") {
output_name = "libClusterObjects"
sources = [
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp",
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/cluster-objects.cpp",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/cluster-objects.h",
]
public_deps = [
@@ -61,8 +66,8 @@ static_library("cluster-objects") {
source_set("enums") {
sources = [
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h",
- "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/cluster-enums-check.h",
+ "${chip_project_app_common_include_dir}/app-common/zap-generated/cluster-enums.h",
"CompatEnumNames.h",
]
diff --git a/src/app/common/templates/config-data.yaml b/src/app/common/templates/config-data.yaml
index 53ca4e9525ebe7..ecbd811575db76 100644
--- a/src/app/common/templates/config-data.yaml
+++ b/src/app/common/templates/config-data.yaml
@@ -34,7 +34,8 @@ CommandHandlerInterfaceOnlyClusters:
- Activated Carbon Filter Monitoring
- HEPA Filter Monitoring
- RVC Operational State
- - Sample MEI
+ - Sample External Manufacturer-Specific
+ - Sample Manufacturer-Specific
- Microwave Oven Control
- Chime
- Commissioner Control
@@ -66,7 +67,8 @@ ClustersWithInitFunctions:
- Time Format Localization
- Thermostat
- Mode Select
- - Sample MEI
+ - Sample External Manufacturer-Specific
+ - Sample Manufacturer-Specific
- Scenes Management
ClustersWithAttributeChangedFunctions:
@@ -84,7 +86,8 @@ ClustersWithShutdownFunctions:
- Door Lock
- Level Control
- Color Control
- - Sample MEI
+ - Sample External Manufacturer-Specific
+ - Sample Manufacturer-Specific
- Scenes Management
- Thermostat
diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml
index d2ff0cb2d0f27e..4ad8188aa65295 100644
--- a/src/app/tests/suites/TestCluster.yaml
+++ b/src/app/tests/suites/TestCluster.yaml
@@ -1317,7 +1317,7 @@ tests:
h: 0.1,
}
- - label: "Send MEI command in cluster"
+ - label: "Send Manufacturer-specific command in cluster"
command: "TestDifferentVendorMeiRequest"
arguments:
values:
@@ -3873,13 +3873,13 @@ tests:
# here yet.
error: FAILURE
- - label: "Write different vendor MEI attribute"
+ - label: "Write different vendor Manufacturer-specific attribute"
command: "writeAttribute"
attribute: "mei_int8u"
arguments:
value: 201
- - label: "Verify different vendor MEI attribute"
+ - label: "Verify different vendor Manufacturer-specific attribute"
command: "readAttribute"
attribute: "mei_int8u"
response:
diff --git a/src/app/zap-templates/zcl/data-model/chip/sample-mei-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/sample-manufacturer-specific-cluster.xml
similarity index 92%
rename from src/app/zap-templates/zcl/data-model/chip/sample-mei-cluster.xml
rename to src/app/zap-templates/zcl/data-model/chip/sample-manufacturer-specific-cluster.xml
index 9b812b85c535d3..bddcf006b35132 100644
--- a/src/app/zap-templates/zcl/data-model/chip/sample-mei-cluster.xml
+++ b/src/app/zap-templates/zcl/data-model/chip/sample-manufacturer-specific-cluster.xml
@@ -19,14 +19,14 @@ limitations under the License.
<cluster>
<domain>General</domain>
- <name>Sample MEI</name>
+ <name>Sample Manufacturer-Specific</name>
<!-- The MSB 16 bits of <code> are the VendorID. Replace this with your
VendorID. 0xFFF1 is a Test VendorID.
The LSB 16 bits of <code> are a self-assigned ClusterID -->
<code>0xFFF1FC20</code>
- <define>SAMPLE_MEI_CLUSTER</define>
- <description>The Sample MEI cluster showcases a cluster manufacturer extensions</description>
+ <define>SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER</define>
+ <description>A manufacturer-specific sample cluster</description>
<!-- Attributes -->
<!-- A simple boolean attribute that flips or flops -->
diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json
index 6aa9408f715c53..413cb929099113 100644
--- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json
+++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json
@@ -139,7 +139,7 @@
"wifi-network-management-cluster.xml",
"window-covering.xml",
"matter-devices.xml",
- "sample-mei-cluster.xml",
+ "sample-manufacturer-specific-cluster.xml",
"types/door-lock.xml",
"types/occupancy-sensing.xml",
"types/thermostat-user-interface-configuration.xml",
diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json
index 836126d877426f..fe247ca41cb609 100644
--- a/src/app/zap-templates/zcl/zcl.json
+++ b/src/app/zap-templates/zcl/zcl.json
@@ -133,7 +133,7 @@
"wifi-network-management-cluster.xml",
"window-covering.xml",
"matter-devices.xml",
- "sample-mei-cluster.xml",
+ "sample-manufacturer-specific-cluster.xml",
"types/door-lock.xml",
"types/occupancy-sensing.xml",
"types/thermostat-user-interface-configuration.xml",
diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json
index 7f9fe4a7dcd25f..62cf236e215c04 100644
--- a/src/app/zap_cluster_list.json
+++ b/src/app/zap_cluster_list.json
@@ -69,7 +69,7 @@
"MESSAGES_CLUSTER": [],
"MODE_SELECT_CLUSTER": [],
"NETWORK_COMMISSIONING_CLUSTER": [],
- "SAMPLE_MEI_CLUSTER": [],
+ "SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER": [],
"NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [],
"OCCUPANCY_SENSING_CLUSTER": [],
"ON_OFF_CLUSTER": [],
@@ -233,7 +233,9 @@
"NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [
"concentration-measurement-server"
],
- "SAMPLE_MEI_CLUSTER": ["sample-mei-server"],
+ "SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER": [
+ "sample-manufacturer-specific-server"
+ ],
"OCCUPANCY_SENSING_CLUSTER": ["occupancy-sensor-server"],
"ON_OFF_CLUSTER": ["on-off-server"],
"POWER_TOPOLOGY_CLUSTER": ["power-topology-server"],
diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter
index 492c4c50b706c8..3e37347178efe4 100644
--- a/src/controller/data_model/controller-clusters.matter
+++ b/src/controller/data_model/controller-clusters.matter
@@ -10804,8 +10804,8 @@ internal cluster FaultInjection = 4294048774 {
command access(invoke: manage) FailRandomlyAtFault(FailRandomlyAtFaultRequest): DefaultSuccess = 1;
}
-/** The Sample MEI cluster showcases a cluster manufacturer extensions */
-cluster SampleMei = 4294048800 {
+/** A manufacturer-specific sample cluster */
+cluster SampleManufacturerSpecific = 4294048800 {
revision 1; // NOTE: Default/not specifically set
fabric_sensitive info event PingCountEvent = 0 {
diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap
index 8c1eba99077039..70f5747e494e32 100644
--- a/src/controller/data_model/controller-clusters.zap
+++ b/src/controller/data_model/controller-clusters.zap
@@ -3194,10 +3194,10 @@
]
},
{
- "name": "Sample MEI",
+ "name": "Sample Manufacturer-specific cluster",
"code": 4294048800,
"mfgCode": null,
- "define": "SAMPLE_MEI_CLUSTER",
+ "define": "SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER",
"side": "client",
"enabled": 1,
"commands": [
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
index d8326291377418..d91dcc58e914e0 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
@@ -68865,7 +68865,7 @@ public void onSuccess(byte[] tlv) {
}
}
- public static class SampleMeiCluster extends BaseChipCluster {
+ public static class SampleManufacturerSpecificCluster extends BaseChipCluster {
public static final long CLUSTER_ID = 4294048800L;
private static final long FLIP_FLOP_ATTRIBUTE_ID = 0L;
@@ -68876,7 +68876,7 @@ public static class SampleMeiCluster extends BaseChipCluster {
private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
- public SampleMeiCluster(long devicePtr, int endpointId) {
+ public SampleManufacturerSpecificCluster(long devicePtr, int endpointId) {
super(devicePtr, endpointId, CLUSTER_ID);
}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
index 8905c909a086e2..d2ef9f76c08fd7 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
@@ -7081,13 +7081,13 @@ public String toString() {
return output.toString();
}
}
-public static class SampleMeiClusterPingCountEventEvent {
+public static class SampleManufacturerSpecificClusterPingCountEventEvent {
public Long count;
public Integer fabricIndex;
private static final long COUNT_ID = 1L;
private static final long FABRIC_INDEX_ID = 254L;
- public SampleMeiClusterPingCountEventEvent(
+ public SampleManufacturerSpecificClusterPingCountEventEvent(
Long count,
Integer fabricIndex
) {
@@ -7103,7 +7103,7 @@ public StructType encodeTlv() {
return new StructType(values);
}
- public static SampleMeiClusterPingCountEventEvent decodeTlv(BaseTLVType tlvValue) {
+ public static SampleManufacturerSpecificClusterPingCountEventEvent decodeTlv(BaseTLVType tlvValue) {
if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
return null;
}
@@ -7122,7 +7122,7 @@ public static SampleMeiClusterPingCountEventEvent decodeTlv(BaseTLVType tlvValue
}
}
}
- return new SampleMeiClusterPingCountEventEvent(
+ return new SampleManufacturerSpecificClusterPingCountEventEvent(
count,
fabricIndex
);
@@ -7131,7 +7131,7 @@ public static SampleMeiClusterPingCountEventEvent decodeTlv(BaseTLVType tlvValue
@Override
public String toString() {
StringBuilder output = new StringBuilder();
- output.append("SampleMeiClusterPingCountEventEvent {\n");
+ output.append("SampleManufacturerSpecificClusterPingCountEventEvent {\n");
output.append("\tcount: ");
output.append(count);
output.append("\n");
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java
index e8440163d37360..d53be86b74bc55 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java
@@ -409,8 +409,8 @@ public static BaseCluster getCluster(long clusterId) {
if (clusterId == FaultInjection.ID) {
return new FaultInjection();
}
- if (clusterId == SampleMei.ID) {
- return new SampleMei();
+ if (clusterId == SampleManufacturerSpecific.ID) {
+ return new SampleManufacturerSpecific();
}return null;
}
public static class Identify implements BaseCluster {
@@ -19047,7 +19047,7 @@ public long getCommandID(String name) throws IllegalArgumentException {
return Command.valueOf(name).getID();
}
}
- public static class SampleMei implements BaseCluster {
+ public static class SampleManufacturerSpecific implements BaseCluster {
public static final long ID = 4294048800L;
public long getID() {
return ID;
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java
index f36a31e142d695..31c23c48e7c1a4 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java
@@ -22752,7 +22752,7 @@ public void onError(Exception ex) {
}
- public static class DelegatedSampleMeiClusterAddArgumentsResponseCallback implements ChipClusters.SampleMeiCluster.AddArgumentsResponseCallback, DelegatedClusterCallback {
+ public static class DelegatedSampleManufacturerSpecificClusterAddArgumentsResponseCallback implements ChipClusters.SampleManufacturerSpecificCluster.AddArgumentsResponseCallback, DelegatedClusterCallback {
private ClusterCommandCallback callback;
@Override
public void setCallbackDelegate(ClusterCommandCallback callback) {
@@ -22773,7 +22773,7 @@ public void onError(Exception error) {
callback.onFailure(error);
}
}
- public static class DelegatedSampleMeiClusterGeneratedCommandListAttributeCallback implements ChipClusters.SampleMeiCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback {
+ public static class DelegatedSampleManufacturerSpecificClusterGeneratedCommandListAttributeCallback implements ChipClusters.SampleManufacturerSpecificCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback {
private ClusterCommandCallback callback;
@Override
public void setCallbackDelegate(ClusterCommandCallback callback) {
@@ -22794,7 +22794,7 @@ public void onError(Exception ex) {
}
}
- public static class DelegatedSampleMeiClusterAcceptedCommandListAttributeCallback implements ChipClusters.SampleMeiCluster.AcceptedCommandListAttributeCallback, DelegatedClusterCallback {
+ public static class DelegatedSampleManufacturerSpecificClusterAcceptedCommandListAttributeCallback implements ChipClusters.SampleManufacturerSpecificCluster.AcceptedCommandListAttributeCallback, DelegatedClusterCallback {
private ClusterCommandCallback callback;
@Override
public void setCallbackDelegate(ClusterCommandCallback callback) {
@@ -22815,7 +22815,7 @@ public void onError(Exception ex) {
}
}
- public static class DelegatedSampleMeiClusterEventListAttributeCallback implements ChipClusters.SampleMeiCluster.EventListAttributeCallback, DelegatedClusterCallback {
+ public static class DelegatedSampleManufacturerSpecificClusterEventListAttributeCallback implements ChipClusters.SampleManufacturerSpecificCluster.EventListAttributeCallback, DelegatedClusterCallback {
private ClusterCommandCallback callback;
@Override
public void setCallbackDelegate(ClusterCommandCallback callback) {
@@ -22836,7 +22836,7 @@ public void onError(Exception ex) {
}
}
- public static class DelegatedSampleMeiClusterAttributeListAttributeCallback implements ChipClusters.SampleMeiCluster.AttributeListAttributeCallback, DelegatedClusterCallback {
+ public static class DelegatedSampleManufacturerSpecificClusterAttributeListAttributeCallback implements ChipClusters.SampleManufacturerSpecificCluster.AttributeListAttributeCallback, DelegatedClusterCallback {
private ClusterCommandCallback callback;
@Override
public void setCallbackDelegate(ClusterCommandCallback callback) {
@@ -23380,9 +23380,9 @@ public Map<String, ClusterInfo> initializeClusterMap() {
(ptr, endpointId) -> new ChipClusters.FaultInjectionCluster(ptr, endpointId), new HashMap<>());
clusterMap.put("faultInjection", faultInjectionClusterInfo);
- ClusterInfo sampleMeiClusterInfo = new ClusterInfo(
- (ptr, endpointId) -> new ChipClusters.SampleMeiCluster(ptr, endpointId), new HashMap<>());
- clusterMap.put("sampleMei", sampleMeiClusterInfo);
+ ClusterInfo sampleManufacturerSpecificClusterInfo = new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.SampleManufacturerSpecificCluster(ptr, endpointId), new HashMap<>());
+ clusterMap.put("sampleManufacturerSpecific", sampleManufacturerSpecificClusterInfo);
return clusterMap;
}
@@ -23515,7 +23515,7 @@ public void combineCommand(Map<String, ClusterInfo> destination, Map<String, Map
destination.get("commissionerControl").combineCommands(source.get("commissionerControl"));
destination.get("unitTesting").combineCommands(source.get("unitTesting"));
destination.get("faultInjection").combineCommands(source.get("faultInjection"));
- destination.get("sampleMei").combineCommands(source.get("sampleMei"));
+ destination.get("sampleManufacturerSpecific").combineCommands(source.get("sampleManufacturerSpecific"));
}
@SuppressWarnings("unchecked")
@@ -31210,31 +31210,31 @@ public Map<String, Map<String, InteractionInfo>> getCommandMap() {
commandMap.put("faultInjection", faultInjectionClusterInteractionInfoMap);
- Map<String, InteractionInfo> sampleMeiClusterInteractionInfoMap = new LinkedHashMap<>();
+ Map<String, InteractionInfo> sampleManufacturerSpecificClusterInteractionInfoMap = new LinkedHashMap<>();
- Map<String, CommandParameterInfo> sampleMeipingCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo sampleMeipingInteractionInfo = new InteractionInfo(
+ Map<String, CommandParameterInfo> sampleManufacturerSpecificpingCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo sampleManufacturerSpecificpingInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster)
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster)
.ping((DefaultClusterCallback) callback
);
},
() -> new DelegatedDefaultClusterCallback(),
- sampleMeipingCommandParams
+ sampleManufacturerSpecificpingCommandParams
);
- sampleMeiClusterInteractionInfoMap.put("ping", sampleMeipingInteractionInfo);
+ sampleManufacturerSpecificClusterInteractionInfoMap.put("ping", sampleManufacturerSpecificpingInteractionInfo);
- Map<String, CommandParameterInfo> sampleMeiaddArgumentsCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ Map<String, CommandParameterInfo> sampleManufacturerSpecificaddArgumentsCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- CommandParameterInfo sampleMeiaddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class, Integer.class);
- sampleMeiaddArgumentsCommandParams.put("arg1",sampleMeiaddArgumentsarg1CommandParameterInfo);
+ CommandParameterInfo sampleManufacturerSpecificaddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class, Integer.class);
+ sampleManufacturerSpecificaddArgumentsCommandParams.put("arg1",sampleManufacturerSpecificaddArgumentsarg1CommandParameterInfo);
- CommandParameterInfo sampleMeiaddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class, Integer.class);
- sampleMeiaddArgumentsCommandParams.put("arg2",sampleMeiaddArgumentsarg2CommandParameterInfo);
- InteractionInfo sampleMeiaddArgumentsInteractionInfo = new InteractionInfo(
+ CommandParameterInfo sampleManufacturerSpecificaddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class, Integer.class);
+ sampleManufacturerSpecificaddArgumentsCommandParams.put("arg2",sampleManufacturerSpecificaddArgumentsarg2CommandParameterInfo);
+ InteractionInfo sampleManufacturerSpecificaddArgumentsInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster)
- .addArguments((ChipClusters.SampleMeiCluster.AddArgumentsResponseCallback) callback
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster)
+ .addArguments((ChipClusters.SampleManufacturerSpecificCluster.AddArgumentsResponseCallback) callback
, (Integer)
commandArguments.get("arg1")
@@ -31243,12 +31243,12 @@ public Map<String, Map<String, InteractionInfo>> getCommandMap() {
);
},
- () -> new DelegatedSampleMeiClusterAddArgumentsResponseCallback(),
- sampleMeiaddArgumentsCommandParams
+ () -> new DelegatedSampleManufacturerSpecificClusterAddArgumentsResponseCallback(),
+ sampleManufacturerSpecificaddArgumentsCommandParams
);
- sampleMeiClusterInteractionInfoMap.put("addArguments", sampleMeiaddArgumentsInteractionInfo);
+ sampleManufacturerSpecificClusterInteractionInfoMap.put("addArguments", sampleManufacturerSpecificaddArgumentsInteractionInfo);
- commandMap.put("sampleMei", sampleMeiClusterInteractionInfoMap);
+ commandMap.put("sampleManufacturerSpecific", sampleManufacturerSpecificClusterInteractionInfoMap);
return commandMap;
}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
index 3323ad5632be1d..39da86043b76dc 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
@@ -20432,84 +20432,84 @@ private static Map<String, InteractionInfo> readFaultInjectionInteractionInfo()
return result;
}
- private static Map<String, InteractionInfo> readSampleMeiInteractionInfo() {
- Map<String, InteractionInfo> result = new LinkedHashMap<>();Map<String, CommandParameterInfo> readSampleMeiFlipFlopCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiFlipFlopAttributeInteractionInfo = new InteractionInfo(
+ private static Map<String, InteractionInfo> readSampleManufacturerSpecificInteractionInfo() {
+ Map<String, InteractionInfo> result = new LinkedHashMap<>();Map<String, CommandParameterInfo> readSampleManufacturerSpecificFlipFlopCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificFlipFlopAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readFlipFlopAttribute(
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readFlipFlopAttribute(
(ChipClusters.BooleanAttributeCallback) callback
);
},
() -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(),
- readSampleMeiFlipFlopCommandParams
+ readSampleManufacturerSpecificFlipFlopCommandParams
);
- result.put("readFlipFlopAttribute", readSampleMeiFlipFlopAttributeInteractionInfo);
- Map<String, CommandParameterInfo> readSampleMeiGeneratedCommandListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiGeneratedCommandListAttributeInteractionInfo = new InteractionInfo(
+ result.put("readFlipFlopAttribute", readSampleManufacturerSpecificFlipFlopAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readSampleManufacturerSpecificGeneratedCommandListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificGeneratedCommandListAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readGeneratedCommandListAttribute(
- (ChipClusters.SampleMeiCluster.GeneratedCommandListAttributeCallback) callback
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readGeneratedCommandListAttribute(
+ (ChipClusters.SampleManufacturerSpecificCluster.GeneratedCommandListAttributeCallback) callback
);
},
- () -> new ClusterInfoMapping.DelegatedSampleMeiClusterGeneratedCommandListAttributeCallback(),
- readSampleMeiGeneratedCommandListCommandParams
+ () -> new ClusterInfoMapping.DelegatedSampleManufacturerSpecificClusterGeneratedCommandListAttributeCallback(),
+ readSampleManufacturerSpecificGeneratedCommandListCommandParams
);
- result.put("readGeneratedCommandListAttribute", readSampleMeiGeneratedCommandListAttributeInteractionInfo);
- Map<String, CommandParameterInfo> readSampleMeiAcceptedCommandListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiAcceptedCommandListAttributeInteractionInfo = new InteractionInfo(
+ result.put("readGeneratedCommandListAttribute", readSampleManufacturerSpecificGeneratedCommandListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readSampleManufacturerSpecificAcceptedCommandListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificAcceptedCommandListAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readAcceptedCommandListAttribute(
- (ChipClusters.SampleMeiCluster.AcceptedCommandListAttributeCallback) callback
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readAcceptedCommandListAttribute(
+ (ChipClusters.SampleManufacturerSpecificCluster.AcceptedCommandListAttributeCallback) callback
);
},
- () -> new ClusterInfoMapping.DelegatedSampleMeiClusterAcceptedCommandListAttributeCallback(),
- readSampleMeiAcceptedCommandListCommandParams
+ () -> new ClusterInfoMapping.DelegatedSampleManufacturerSpecificClusterAcceptedCommandListAttributeCallback(),
+ readSampleManufacturerSpecificAcceptedCommandListCommandParams
);
- result.put("readAcceptedCommandListAttribute", readSampleMeiAcceptedCommandListAttributeInteractionInfo);
- Map<String, CommandParameterInfo> readSampleMeiEventListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiEventListAttributeInteractionInfo = new InteractionInfo(
+ result.put("readAcceptedCommandListAttribute", readSampleManufacturerSpecificAcceptedCommandListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readSampleManufacturerSpecificEventListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificEventListAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readEventListAttribute(
- (ChipClusters.SampleMeiCluster.EventListAttributeCallback) callback
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readEventListAttribute(
+ (ChipClusters.SampleManufacturerSpecificCluster.EventListAttributeCallback) callback
);
},
- () -> new ClusterInfoMapping.DelegatedSampleMeiClusterEventListAttributeCallback(),
- readSampleMeiEventListCommandParams
+ () -> new ClusterInfoMapping.DelegatedSampleManufacturerSpecificClusterEventListAttributeCallback(),
+ readSampleManufacturerSpecificEventListCommandParams
);
- result.put("readEventListAttribute", readSampleMeiEventListAttributeInteractionInfo);
- Map<String, CommandParameterInfo> readSampleMeiAttributeListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiAttributeListAttributeInteractionInfo = new InteractionInfo(
+ result.put("readEventListAttribute", readSampleManufacturerSpecificEventListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readSampleManufacturerSpecificAttributeListCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificAttributeListAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readAttributeListAttribute(
- (ChipClusters.SampleMeiCluster.AttributeListAttributeCallback) callback
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readAttributeListAttribute(
+ (ChipClusters.SampleManufacturerSpecificCluster.AttributeListAttributeCallback) callback
);
},
- () -> new ClusterInfoMapping.DelegatedSampleMeiClusterAttributeListAttributeCallback(),
- readSampleMeiAttributeListCommandParams
+ () -> new ClusterInfoMapping.DelegatedSampleManufacturerSpecificClusterAttributeListAttributeCallback(),
+ readSampleManufacturerSpecificAttributeListCommandParams
);
- result.put("readAttributeListAttribute", readSampleMeiAttributeListAttributeInteractionInfo);
- Map<String, CommandParameterInfo> readSampleMeiFeatureMapCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiFeatureMapAttributeInteractionInfo = new InteractionInfo(
+ result.put("readAttributeListAttribute", readSampleManufacturerSpecificAttributeListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readSampleManufacturerSpecificFeatureMapCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificFeatureMapAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readFeatureMapAttribute(
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readFeatureMapAttribute(
(ChipClusters.LongAttributeCallback) callback
);
},
() -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
- readSampleMeiFeatureMapCommandParams
+ readSampleManufacturerSpecificFeatureMapCommandParams
);
- result.put("readFeatureMapAttribute", readSampleMeiFeatureMapAttributeInteractionInfo);
- Map<String, CommandParameterInfo> readSampleMeiClusterRevisionCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- InteractionInfo readSampleMeiClusterRevisionAttributeInteractionInfo = new InteractionInfo(
+ result.put("readFeatureMapAttribute", readSampleManufacturerSpecificFeatureMapAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readSampleManufacturerSpecificClusterRevisionCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readSampleManufacturerSpecificClusterRevisionAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).readClusterRevisionAttribute(
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).readClusterRevisionAttribute(
(ChipClusters.IntegerAttributeCallback) callback
);
},
() -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
- readSampleMeiClusterRevisionCommandParams
+ readSampleManufacturerSpecificClusterRevisionCommandParams
);
- result.put("readClusterRevisionAttribute", readSampleMeiClusterRevisionAttributeInteractionInfo);
+ result.put("readClusterRevisionAttribute", readSampleManufacturerSpecificClusterRevisionAttributeInteractionInfo);
return result;
}
@@ -20644,7 +20644,7 @@ public Map<String, Map<String, InteractionInfo>> getReadAttributeMap() {
put("commissionerControl", readCommissionerControlInteractionInfo());
put("unitTesting", readUnitTestingInteractionInfo());
put("faultInjection", readFaultInjectionInteractionInfo());
- put("sampleMei", readSampleMeiInteractionInfo());}};
+ put("sampleManufacturerSpecific", readSampleManufacturerSpecificInteractionInfo());}};
}
}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
index 6df2ad6b8104e9..63ce9da4821095 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
@@ -5538,29 +5538,29 @@ public Map<String, Map<String, InteractionInfo>> getWriteAttributeMap() {
writeAttributeMap.put("unitTesting", writeUnitTestingInteractionInfo);
Map<String, InteractionInfo> writeFaultInjectionInteractionInfo = new LinkedHashMap<>();
writeAttributeMap.put("faultInjection", writeFaultInjectionInteractionInfo);
- Map<String, InteractionInfo> writeSampleMeiInteractionInfo = new LinkedHashMap<>();
- Map<String, CommandParameterInfo> writeSampleMeiFlipFlopCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
- CommandParameterInfo sampleMeiflipFlopCommandParameterInfo =
+ Map<String, InteractionInfo> writeSampleManufacturerSpecificInteractionInfo = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> writeSampleManufacturerSpecificFlipFlopCommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ CommandParameterInfo sampleManufacturerSpecificflipFlopCommandParameterInfo =
new CommandParameterInfo(
"value",
Boolean.class,
Boolean.class
);
- writeSampleMeiFlipFlopCommandParams.put(
+ writeSampleManufacturerSpecificFlipFlopCommandParams.put(
"value",
- sampleMeiflipFlopCommandParameterInfo
+ sampleManufacturerSpecificflipFlopCommandParameterInfo
);
- InteractionInfo writeSampleMeiFlipFlopAttributeInteractionInfo = new InteractionInfo(
+ InteractionInfo writeSampleManufacturerSpecificFlipFlopAttributeInteractionInfo = new InteractionInfo(
(cluster, callback, commandArguments) -> {
- ((ChipClusters.SampleMeiCluster) cluster).writeFlipFlopAttribute(
+ ((ChipClusters.SampleManufacturerSpecificCluster) cluster).writeFlipFlopAttribute(
(DefaultClusterCallback) callback,
(Boolean) commandArguments.get("value")
);
},
() -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(),
- writeSampleMeiFlipFlopCommandParams
+ writeSampleManufacturerSpecificFlipFlopCommandParams
);
- writeSampleMeiInteractionInfo.put("writeFlipFlopAttribute", writeSampleMeiFlipFlopAttributeInteractionInfo);
- writeAttributeMap.put("sampleMei", writeSampleMeiInteractionInfo);return writeAttributeMap;
+ writeSampleManufacturerSpecificInteractionInfo.put("writeFlipFlopAttribute", writeSampleManufacturerSpecificFlipFlopAttributeInteractionInfo);
+ writeAttributeMap.put("sampleManufacturerSpecific", writeSampleManufacturerSpecificInteractionInfo);return writeAttributeMap;
}
}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt
similarity index 80%
rename from src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt
rename to src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt
index a0588f4ad66d56..5288d68e46d456 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt
@@ -22,9 +22,12 @@ import matter.tlv.Tag
import matter.tlv.TlvReader
import matter.tlv.TlvWriter
-class SampleMeiClusterPingCountEventEvent(val count: ULong, val fabricIndex: UInt) {
+class SampleManufacturerSpecificClusterPingCountEventEvent(
+ val count: ULong,
+ val fabricIndex: UInt,
+) {
override fun toString(): String = buildString {
- append("SampleMeiClusterPingCountEventEvent {\n")
+ append("SampleManufacturerSpecificClusterPingCountEventEvent {\n")
append("\tcount : $count\n")
append("\tfabricIndex : $fabricIndex\n")
append("}\n")
@@ -43,14 +46,17 @@ class SampleMeiClusterPingCountEventEvent(val count: ULong, val fabricIndex: UIn
private const val TAG_COUNT = 1
private const val TAG_FABRIC_INDEX = 254
- fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): SampleMeiClusterPingCountEventEvent {
+ fun fromTlv(
+ tlvTag: Tag,
+ tlvReader: TlvReader,
+ ): SampleManufacturerSpecificClusterPingCountEventEvent {
tlvReader.enterStructure(tlvTag)
val count = tlvReader.getULong(ContextSpecificTag(TAG_COUNT))
val fabricIndex = tlvReader.getUInt(ContextSpecificTag(TAG_FABRIC_INDEX))
tlvReader.exitContainer()
- return SampleMeiClusterPingCountEventEvent(count, fabricIndex)
+ return SampleManufacturerSpecificClusterPingCountEventEvent(count, fabricIndex)
}
}
}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni
index 142702d10eca43..17f218655a1028 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni
@@ -242,7 +242,7 @@ eventstructs_sources = [
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/RefrigeratorAlarmClusterNotifyEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/RvcOperationalStateClusterOperationalErrorEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/RvcOperationalStateClusterOperationCompletionEvent.kt",
- "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterCOAlarmEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectCOAlarmEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectSmokeAlarmEvent.kt",
diff --git a/src/controller/java/generated/java/matter/controller/cluster/clusters/SampleMeiCluster.kt b/src/controller/java/generated/java/matter/controller/cluster/clusters/SampleManufacturerSpecificCluster.kt
similarity index 99%
rename from src/controller/java/generated/java/matter/controller/cluster/clusters/SampleMeiCluster.kt
rename to src/controller/java/generated/java/matter/controller/cluster/clusters/SampleManufacturerSpecificCluster.kt
index 0c96750d8a58e5..12115065aacaf4 100644
--- a/src/controller/java/generated/java/matter/controller/cluster/clusters/SampleMeiCluster.kt
+++ b/src/controller/java/generated/java/matter/controller/cluster/clusters/SampleManufacturerSpecificCluster.kt
@@ -43,7 +43,10 @@ import matter.tlv.ContextSpecificTag
import matter.tlv.TlvReader
import matter.tlv.TlvWriter
-class SampleMeiCluster(private val controller: MatterController, private val endpointId: UShort) {
+class SampleManufacturerSpecificCluster(
+ private val controller: MatterController,
+ private val endpointId: UShort,
+) {
class AddArgumentsResponse(val returnValue: UByte)
class GeneratedCommandListAttribute(val value: List<UInt>)
@@ -825,7 +828,7 @@ class SampleMeiCluster(private val controller: MatterController, private val end
}
companion object {
- private val logger = Logger.getLogger(SampleMeiCluster::class.java.name)
+ private val logger = Logger.getLogger(SampleManufacturerSpecificCluster::class.java.name)
const val CLUSTER_ID: UInt = 4294048800u
}
}
diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt
similarity index 80%
rename from src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt
rename to src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt
index 5570ba7a3af4a3..206ab20e602b3a 100644
--- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt
+++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt
@@ -22,9 +22,12 @@ import matter.tlv.Tag
import matter.tlv.TlvReader
import matter.tlv.TlvWriter
-class SampleMeiClusterPingCountEventEvent(val count: UInt, val fabricIndex: UByte) {
+class SampleManufacturerSpecificClusterPingCountEventEvent(
+ val count: UInt,
+ val fabricIndex: UByte,
+) {
override fun toString(): String = buildString {
- append("SampleMeiClusterPingCountEventEvent {\n")
+ append("SampleManufacturerSpecificClusterPingCountEventEvent {\n")
append("\tcount : $count\n")
append("\tfabricIndex : $fabricIndex\n")
append("}\n")
@@ -43,14 +46,17 @@ class SampleMeiClusterPingCountEventEvent(val count: UInt, val fabricIndex: UByt
private const val TAG_COUNT = 1
private const val TAG_FABRIC_INDEX = 254
- fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): SampleMeiClusterPingCountEventEvent {
+ fun fromTlv(
+ tlvTag: Tag,
+ tlvReader: TlvReader,
+ ): SampleManufacturerSpecificClusterPingCountEventEvent {
tlvReader.enterStructure(tlvTag)
val count = tlvReader.getUInt(ContextSpecificTag(TAG_COUNT))
val fabricIndex = tlvReader.getUByte(ContextSpecificTag(TAG_FABRIC_INDEX))
tlvReader.exitContainer()
- return SampleMeiClusterPingCountEventEvent(count, fabricIndex)
+ return SampleManufacturerSpecificClusterPingCountEventEvent(count, fabricIndex)
}
}
}
diff --git a/src/controller/java/generated/java/matter/controller/cluster/files.gni b/src/controller/java/generated/java/matter/controller/cluster/files.gni
index 700f257e643888..ed3f7b8735afc6 100644
--- a/src/controller/java/generated/java/matter/controller/cluster/files.gni
+++ b/src/controller/java/generated/java/matter/controller/cluster/files.gni
@@ -242,7 +242,7 @@ matter_eventstructs_sources = [
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/RefrigeratorAlarmClusterNotifyEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/RvcOperationalStateClusterOperationalErrorEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/RvcOperationalStateClusterOperationCompletionEvent.kt",
- "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleMeiClusterPingCountEventEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SampleManufacturerSpecificClusterPingCountEventEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SmokeCoAlarmClusterCOAlarmEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectCOAlarmEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectSmokeAlarmEvent.kt",
@@ -372,7 +372,7 @@ matter_clusters_sources = [
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/RvcCleanModeCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/RvcOperationalStateCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/RvcRunModeCluster.kt",
- "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/SampleMeiCluster.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/SampleManufacturerSpecificCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/ScenesManagementCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/ServiceAreaCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/SmokeCoAlarmCluster.kt",
diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
index 1c959aa8fc3c15..54e407fa5998af 100644
--- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
+++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
@@ -46313,8 +46313,8 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
}
break;
}
- case app::Clusters::SampleMei::Id: {
- using namespace app::Clusters::SampleMei;
+ case app::Clusters::SampleManufacturerSpecific::Id: {
+ using namespace app::Clusters::SampleManufacturerSpecific;
switch (aPath.mAttributeId)
{
case Attributes::FlipFlop::Id: {
diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
index 91d5466f759665..4ca9a1861b72fd 100644
--- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
+++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
@@ -9564,8 +9564,8 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader &
}
break;
}
- case app::Clusters::SampleMei::Id: {
- using namespace app::Clusters::SampleMei;
+ case app::Clusters::SampleManufacturerSpecific::Id: {
+ using namespace app::Clusters::SampleManufacturerSpecific;
switch (aPath.mEventId)
{
case Events::PingCountEvent::Id: {
@@ -9592,10 +9592,11 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader &
jclass pingCountEventStructClass;
err = chip::JniReferences::GetInstance().GetLocalClassRef(
- env, "chip/devicecontroller/ChipEventStructs$SampleMeiClusterPingCountEventEvent", pingCountEventStructClass);
+ env, "chip/devicecontroller/ChipEventStructs$SampleManufacturerSpecificClusterPingCountEventEvent",
+ pingCountEventStructClass);
if (err != CHIP_NO_ERROR)
{
- ChipLogError(Zcl, "Could not find class ChipEventStructs$SampleMeiClusterPingCountEventEvent");
+ ChipLogError(Zcl, "Could not find class ChipEventStructs$SampleManufacturerSpecificClusterPingCountEventEvent");
return nullptr;
}
@@ -9604,7 +9605,8 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader &
env, pingCountEventStructClass, "<init>", "(Ljava/lang/Long;Ljava/lang/Integer;)V", &pingCountEventStructCtor);
if (err != CHIP_NO_ERROR || pingCountEventStructCtor == nullptr)
{
- ChipLogError(Zcl, "Could not find ChipEventStructs$SampleMeiClusterPingCountEventEvent constructor");
+ ChipLogError(Zcl,
+ "Could not find ChipEventStructs$SampleManufacturerSpecificClusterPingCountEventEvent constructor");
return nullptr;
}
diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py
index 60e9236bfe38f6..d2dca35d84aa2d 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.py
+++ b/src/controller/python/chip/clusters/CHIPClusters.py
@@ -14199,8 +14199,8 @@ class ChipClusters:
},
},
}
- _SAMPLE_MEI_CLUSTER_INFO = {
- "clusterName": "SampleMei",
+ _SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_INFO = {
+ "clusterName": "SampleManufacturerSpecific",
"clusterId": 0xFFF1FC20,
"commands": {
0x00000000: {
@@ -14387,7 +14387,7 @@ class ChipClusters:
0x00000751: _COMMISSIONER_CONTROL_CLUSTER_INFO,
0xFFF1FC05: _UNIT_TESTING_CLUSTER_INFO,
0xFFF1FC06: _FAULT_INJECTION_CLUSTER_INFO,
- 0xFFF1FC20: _SAMPLE_MEI_CLUSTER_INFO,
+ 0xFFF1FC20: _SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_INFO,
}
_CLUSTER_NAME_DICT = {
@@ -14518,7 +14518,7 @@ class ChipClusters:
"CommissionerControl": _COMMISSIONER_CONTROL_CLUSTER_INFO,
"UnitTesting": _UNIT_TESTING_CLUSTER_INFO,
"FaultInjection": _FAULT_INJECTION_CLUSTER_INFO,
- "SampleMei": _SAMPLE_MEI_CLUSTER_INFO,
+ "SampleManufacturerSpecific": _SAMPLE_MANUFACTURER_SPECIFIC_CLUSTER_INFO,
}
def __init__(self, chipstack):
diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py
index dc6aea8c321eda..8db01f686c5ae8 100644
--- a/src/controller/python/chip/clusters/Objects.py
+++ b/src/controller/python/chip/clusters/Objects.py
@@ -167,7 +167,7 @@
"CommissionerControl",
"UnitTesting",
"FaultInjection",
- "SampleMei",
+ "SampleManufacturerSpecific",
]
@@ -50836,7 +50836,7 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
@dataclass
-class SampleMei(Cluster):
+class SampleManufacturerSpecific(Cluster):
id: typing.ClassVar[int] = 0xFFF1FC20
@ChipUtility.classproperty
diff --git a/src/darwin/Framework/CHIP/templates/availability.yaml b/src/darwin/Framework/CHIP/templates/availability.yaml
index bd0863ef5aa2c0..f0a6cd45867346 100644
--- a/src/darwin/Framework/CHIP/templates/availability.yaml
+++ b/src/darwin/Framework/CHIP/templates/availability.yaml
@@ -7473,7 +7473,7 @@
provisional:
clusters:
# SDK example, not part of the specification.
- - SampleMEI
+ - SampleManufacturerSpecific
attributes:
Scenes:
# New scenes bits not stable yet.
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm
index 53ab30c0991eb8..8fba716fca76a7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm
@@ -6200,9 +6200,9 @@ static BOOL AttributeIsSpecifiedInUnitTestingCluster(AttributeId aAttributeId)
}
}
}
-static BOOL AttributeIsSpecifiedInSampleMEICluster(AttributeId aAttributeId)
+static BOOL AttributeIsSpecifiedInSampleManufacturerSpecificCluster(AttributeId aAttributeId)
{
- using namespace Clusters::SampleMei;
+ using namespace Clusters::SampleManufacturerSpecific;
switch (aAttributeId) {
case Attributes::FlipFlop::Id: {
return YES;
@@ -6600,8 +6600,8 @@ BOOL MTRAttributeIsSpecified(ClusterId aClusterId, AttributeId aAttributeId)
case Clusters::UnitTesting::Id: {
return AttributeIsSpecifiedInUnitTestingCluster(aAttributeId);
}
- case Clusters::SampleMei::Id: {
- return AttributeIsSpecifiedInSampleMEICluster(aAttributeId);
+ case Clusters::SampleManufacturerSpecific::Id: {
+ return AttributeIsSpecifiedInSampleManufacturerSpecificCluster(aAttributeId);
}
default: {
return NO;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm
index adcc11e7beef7a..3a917c18f76212 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm
@@ -19608,9 +19608,9 @@ static id _Nullable DecodeAttributeValueForUnitTestingCluster(AttributeId aAttri
*aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB;
return nil;
}
-static id _Nullable DecodeAttributeValueForSampleMEICluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
+static id _Nullable DecodeAttributeValueForSampleManufacturerSpecificCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
{
- using namespace Clusters::SampleMei;
+ using namespace Clusters::SampleManufacturerSpecific;
switch (aAttributeId) {
case Attributes::FlipFlop::Id: {
using TypeInfo = Attributes::FlipFlop::TypeInfo;
@@ -20008,8 +20008,8 @@ id _Nullable MTRDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::T
case Clusters::UnitTesting::Id: {
return DecodeAttributeValueForUnitTestingCluster(aPath.mAttributeId, aReader, aError);
}
- case Clusters::SampleMei::Id: {
- return DecodeAttributeValueForSampleMEICluster(aPath.mAttributeId, aReader, aError);
+ case Clusters::SampleManufacturerSpecific::Id: {
+ return DecodeAttributeValueForSampleManufacturerSpecificCluster(aPath.mAttributeId, aReader, aError);
}
default: {
break;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h
index 887015ba107a8c..b089fc8bf45925 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h
@@ -15980,19 +15980,19 @@ MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4))
@end
/**
- * Cluster Sample MEI
+ * Cluster Sample Manufacturer-Specific
*
- * The Sample MEI cluster showcases a cluster manufacturer extensions
+ * A manufacturer-specific sample cluster
*/
MTR_PROVISIONALLY_AVAILABLE
-@interface MTRBaseClusterSampleMEI : MTRGenericBaseCluster
+@interface MTRBaseClusterSampleManufacturerSpecific : MTRGenericBaseCluster
/**
* Command Ping
*
* Simple command without any parameters and without a response.
*/
-- (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE;
+- (void)pingWithParams:(MTRSampleManufacturerSpecificClusterPingParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE;
- (void)pingWithCompletion:(MTRStatusCompletion)completion
MTR_PROVISIONALLY_AVAILABLE;
/**
@@ -16000,7 +16000,7 @@ MTR_PROVISIONALLY_AVAILABLE
*
* Command that takes two uint8 arguments and returns their sum.
*/
-- (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params completion:(void (^)(MTRSampleMEIClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE;
+- (void)addArgumentsWithParams:(MTRSampleManufacturerSpecificClusterAddArgumentsParams *)params completion:(void (^)(MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE;
- (void)readAttributeFlipFlopWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE;
- (void)writeAttributeFlipFlopWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE;
@@ -16045,7 +16045,7 @@ MTR_PROVISIONALLY_AVAILABLE
@end
-@interface MTRBaseClusterSampleMEI (Availability)
+@interface MTRBaseClusterSampleManufacturerSpecific (Availability)
/**
* For all instance methods (reads, writes, commands) that take a completion,
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
index e8a309f9d15454..5b8d133c4b93a1 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
@@ -113208,16 +113208,16 @@ - (nullable instancetype)initWithDevice:(MTRBaseDevice *)device
@end
-@implementation MTRBaseClusterSampleMEI
+@implementation MTRBaseClusterSampleManufacturerSpecific
- (void)pingWithCompletion:(MTRStatusCompletion)completion
{
[self pingWithParams:nil completion:completion];
}
-- (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params completion:(MTRStatusCompletion)completion
+- (void)pingWithParams:(MTRSampleManufacturerSpecificClusterPingParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
if (params == nil) {
- params = [[MTRSampleMEIClusterPingParams
+ params = [[MTRSampleManufacturerSpecificClusterPingParams
alloc] init];
}
@@ -113227,7 +113227,7 @@ - (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params complet
auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
- using RequestType = SampleMei::Commands::Ping::Type;
+ using RequestType = SampleManufacturerSpecific::Commands::Ping::Type;
[self.device _invokeKnownCommandWithEndpointID:self.endpointID
clusterID:@(RequestType::GetClusterId())
commandID:@(RequestType::GetCommandId())
@@ -113238,10 +113238,10 @@ - (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params complet
queue:self.callbackQueue
completion:responseHandler];
}
-- (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params completion:(void (^)(MTRSampleMEIClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion
+- (void)addArgumentsWithParams:(MTRSampleManufacturerSpecificClusterAddArgumentsParams *)params completion:(void (^)(MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
if (params == nil) {
- params = [[MTRSampleMEIClusterAddArgumentsParams
+ params = [[MTRSampleManufacturerSpecificClusterAddArgumentsParams
alloc] init];
}
@@ -113251,21 +113251,21 @@ - (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params c
auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
- using RequestType = SampleMei::Commands::AddArguments::Type;
+ using RequestType = SampleManufacturerSpecific::Commands::AddArguments::Type;
[self.device _invokeKnownCommandWithEndpointID:self.endpointID
clusterID:@(RequestType::GetClusterId())
commandID:@(RequestType::GetCommandId())
commandPayload:params
timedInvokeTimeout:timedInvokeTimeoutMs
serverSideProcessingTimeout:params.serverSideProcessingTimeout
- responseClass:MTRSampleMEIClusterAddArgumentsResponseParams.class
+ responseClass:MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams.class
queue:self.callbackQueue
completion:responseHandler];
}
- (void)readAttributeFlipFlopWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FlipFlop::TypeInfo;
[self.device _readKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113293,7 +113293,7 @@ - (void)writeAttributeFlipFlopWithValue:(NSNumber * _Nonnull)value params:(MTRWr
}
ListFreer listFreer;
- using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FlipFlop::TypeInfo;
TypeInfo::Type cppValue;
cppValue = value.boolValue;
@@ -113306,7 +113306,7 @@ - (void)subscribeAttributeFlipFlopWithParams:(MTRSubscribeParams * _Nonnull)para
subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
- using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FlipFlop::TypeInfo;
[self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113318,7 +113318,7 @@ - (void)subscribeAttributeFlipFlopWithParams:(MTRSubscribeParams * _Nonnull)para
+ (void)readAttributeFlipFlopWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FlipFlop::TypeInfo;
[clusterStateCacheContainer
_readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
clusterID:TypeInfo::GetClusterId()
@@ -113329,7 +113329,7 @@ + (void)readAttributeFlipFlopWithClusterStateCache:(MTRClusterStateCacheContaine
- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::GeneratedCommandList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::GeneratedCommandList::TypeInfo;
[self.device _readKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113342,7 +113342,7 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
- using TypeInfo = SampleMei::Attributes::GeneratedCommandList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::GeneratedCommandList::TypeInfo;
[self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113354,7 +113354,7 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::GeneratedCommandList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::GeneratedCommandList::TypeInfo;
[clusterStateCacheContainer
_readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
clusterID:TypeInfo::GetClusterId()
@@ -113365,7 +113365,7 @@ + (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateC
- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::AcceptedCommandList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::AcceptedCommandList::TypeInfo;
[self.device _readKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113378,7 +113378,7 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
- using TypeInfo = SampleMei::Attributes::AcceptedCommandList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::AcceptedCommandList::TypeInfo;
[self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113390,7 +113390,7 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::AcceptedCommandList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::AcceptedCommandList::TypeInfo;
[clusterStateCacheContainer
_readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
clusterID:TypeInfo::GetClusterId()
@@ -113401,7 +113401,7 @@ + (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCa
- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::AttributeList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::AttributeList::TypeInfo;
[self.device _readKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113414,7 +113414,7 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
- using TypeInfo = SampleMei::Attributes::AttributeList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::AttributeList::TypeInfo;
[self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113426,7 +113426,7 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::AttributeList::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::AttributeList::TypeInfo;
[clusterStateCacheContainer
_readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
clusterID:TypeInfo::GetClusterId()
@@ -113437,7 +113437,7 @@ + (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheCon
- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::FeatureMap::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FeatureMap::TypeInfo;
[self.device _readKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113450,7 +113450,7 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
- using TypeInfo = SampleMei::Attributes::FeatureMap::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FeatureMap::TypeInfo;
[self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113462,7 +113462,7 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::FeatureMap::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::FeatureMap::TypeInfo;
[clusterStateCacheContainer
_readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
clusterID:TypeInfo::GetClusterId()
@@ -113473,7 +113473,7 @@ + (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContai
- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::ClusterRevision::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::ClusterRevision::TypeInfo;
[self.device _readKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113486,7 +113486,7 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
- using TypeInfo = SampleMei::Attributes::ClusterRevision::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::ClusterRevision::TypeInfo;
[self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
clusterID:@(TypeInfo::GetClusterId())
attributeID:@(TypeInfo::GetAttributeId())
@@ -113498,7 +113498,7 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
- using TypeInfo = SampleMei::Attributes::ClusterRevision::TypeInfo;
+ using TypeInfo = SampleManufacturerSpecific::Attributes::ClusterRevision::TypeInfo;
[clusterStateCacheContainer
_readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
clusterID:TypeInfo::GetClusterId()
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h
index 3081901bc1d25b..dca9f6874f13b9 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h
@@ -206,7 +206,7 @@ typedef NS_ENUM(uint32_t, MTRClusterIDType) {
MTRClusterIDTypeEcosystemInformationID MTR_PROVISIONALLY_AVAILABLE = 0x00000750,
MTRClusterIDTypeCommissionerControlID MTR_PROVISIONALLY_AVAILABLE = 0x00000751,
MTRClusterIDTypeUnitTestingID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0xFFF1FC05,
- MTRClusterIDTypeSampleMEIID MTR_PROVISIONALLY_AVAILABLE = 0xFFF1FC20,
+ MTRClusterIDTypeSampleManufacturerSpecificID MTR_PROVISIONALLY_AVAILABLE = 0xFFF1FC20,
MTRClusterBarrierControlID MTR_DEPRECATED("Please use MTRClusterIDTypeBarrierControlID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) = 0x00000103,
MTRClusterIDTypeBarrierControlID MTR_DEPRECATED("The BarrierControl cluster will be removed", ios(16.4, 18.2), macos(13.3, 15.2), watchos(9.4, 11.2), tvos(16.4, 18.2)) = 0x00000103,
@@ -5093,13 +5093,13 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) {
MTRAttributeIDTypeClusterUnitTestingAttributeClusterRevisionID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = MTRAttributeIDTypeGlobalAttributeClusterRevisionID,
MTRAttributeIDTypeClusterUnitTestingAttributeMeiInt8uID MTR_PROVISIONALLY_AVAILABLE = 0xFFF24F01,
- // Cluster SampleMEI attributes
- MTRAttributeIDTypeClusterSampleMEIAttributeFlipFlopID MTR_PROVISIONALLY_AVAILABLE = 0x00000000,
- MTRAttributeIDTypeClusterSampleMEIAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID,
- MTRAttributeIDTypeClusterSampleMEIAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID,
- MTRAttributeIDTypeClusterSampleMEIAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID,
- MTRAttributeIDTypeClusterSampleMEIAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID,
- MTRAttributeIDTypeClusterSampleMEIAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID,
+ // Cluster SampleManufacturerSpecific attributes
+ MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFlipFlopID MTR_PROVISIONALLY_AVAILABLE = 0x00000000,
+ MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID,
+ MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID,
+ MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID,
+ MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID,
+ MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID,
// Cluster BarrierControl deprecated attribute names
MTRClusterBarrierControlAttributeBarrierMovingStateID
@@ -7108,10 +7108,10 @@ typedef NS_ENUM(uint32_t, MTRCommandIDType) {
MTRCommandIDTypeClusterUnitTestingCommandTestDifferentVendorMeiRequestID MTR_PROVISIONALLY_AVAILABLE = 0xFFF200AA,
MTRCommandIDTypeClusterUnitTestingCommandTestDifferentVendorMeiResponseID MTR_PROVISIONALLY_AVAILABLE = 0xFFF200BB,
- // Cluster SampleMEI commands
- MTRCommandIDTypeClusterSampleMEICommandPingID MTR_PROVISIONALLY_AVAILABLE = 0x00000000,
- MTRCommandIDTypeClusterSampleMEICommandAddArgumentsResponseID MTR_PROVISIONALLY_AVAILABLE = 0x00000001,
- MTRCommandIDTypeClusterSampleMEICommandAddArgumentsID MTR_PROVISIONALLY_AVAILABLE = 0x00000002,
+ // Cluster SampleManufacturerSpecific commands
+ MTRCommandIDTypeClusterSampleManufacturerSpecificCommandPingID MTR_PROVISIONALLY_AVAILABLE = 0x00000000,
+ MTRCommandIDTypeClusterSampleManufacturerSpecificCommandAddArgumentsResponseID MTR_PROVISIONALLY_AVAILABLE = 0x00000001,
+ MTRCommandIDTypeClusterSampleManufacturerSpecificCommandAddArgumentsID MTR_PROVISIONALLY_AVAILABLE = 0x00000002,
// Cluster BarrierControl deprecated command id names
MTRClusterBarrierControlCommandBarrierControlGoToPercentID
@@ -7560,8 +7560,8 @@ typedef NS_ENUM(uint32_t, MTREventIDType) {
MTREventIDTypeClusterUnitTestingEventTestFabricScopedEventID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000002,
MTREventIDTypeClusterUnitTestingEventTestDifferentVendorMeiEventID MTR_PROVISIONALLY_AVAILABLE = 0xFFF200EE,
- // Cluster SampleMEI events
- MTREventIDTypeClusterSampleMEIEventPingCountEventID MTR_PROVISIONALLY_AVAILABLE = 0x00000000,
+ // Cluster SampleManufacturerSpecific events
+ MTREventIDTypeClusterSampleManufacturerSpecificEventPingCountEventID MTR_PROVISIONALLY_AVAILABLE = 0x00000000,
};
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm
index 33c0e2d31eb079..6cc767c7407768 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm
@@ -396,8 +396,8 @@
case MTRClusterIDTypeUnitTestingID:
result = @"UnitTesting";
break;
- case MTRClusterIDTypeSampleMEIID:
- result = @"SampleMEI";
+ case MTRClusterIDTypeSampleManufacturerSpecificID:
+ result = @"SampleManufacturerSpecific";
break;
default:
@@ -8529,32 +8529,32 @@
}
break;
- case MTRClusterIDTypeSampleMEIID:
+ case MTRClusterIDTypeSampleManufacturerSpecificID:
switch (attributeID) {
- // Cluster SampleMEI attributes
- case MTRAttributeIDTypeClusterSampleMEIAttributeFlipFlopID:
+ // Cluster SampleManufacturerSpecific attributes
+ case MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFlipFlopID:
result = @"FlipFlop";
break;
- case MTRAttributeIDTypeClusterSampleMEIAttributeGeneratedCommandListID:
+ case MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeGeneratedCommandListID:
result = @"GeneratedCommandList";
break;
- case MTRAttributeIDTypeClusterSampleMEIAttributeAcceptedCommandListID:
+ case MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeAcceptedCommandListID:
result = @"AcceptedCommandList";
break;
- case MTRAttributeIDTypeClusterSampleMEIAttributeAttributeListID:
+ case MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeAttributeListID:
result = @"AttributeList";
break;
- case MTRAttributeIDTypeClusterSampleMEIAttributeFeatureMapID:
+ case MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFeatureMapID:
result = @"FeatureMap";
break;
- case MTRAttributeIDTypeClusterSampleMEIAttributeClusterRevisionID:
+ case MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeClusterRevisionID:
result = @"ClusterRevision";
break;
@@ -11098,15 +11098,15 @@
}
break;
- case MTRClusterIDTypeSampleMEIID:
+ case MTRClusterIDTypeSampleManufacturerSpecificID:
switch (commandID) {
- case MTRCommandIDTypeClusterSampleMEICommandPingID:
+ case MTRCommandIDTypeClusterSampleManufacturerSpecificCommandPingID:
result = @"Ping";
break;
- case MTRCommandIDTypeClusterSampleMEICommandAddArgumentsID:
+ case MTRCommandIDTypeClusterSampleManufacturerSpecificCommandAddArgumentsID:
result = @"AddArguments";
break;
@@ -12740,11 +12740,11 @@
}
break;
- case MTRClusterIDTypeSampleMEIID:
+ case MTRClusterIDTypeSampleManufacturerSpecificID:
switch (commandID) {
- case MTRCommandIDTypeClusterSampleMEICommandAddArgumentsResponseID:
+ case MTRCommandIDTypeClusterSampleManufacturerSpecificCommandAddArgumentsResponseID:
result = @"AddArgumentsResponse";
break;
@@ -14523,12 +14523,12 @@
}
break;
- case MTRClusterIDTypeSampleMEIID:
+ case MTRClusterIDTypeSampleManufacturerSpecificID:
switch (eventID) {
- // Cluster SampleMEI events
- case MTREventIDTypeClusterSampleMEIEventPingCountEventID:
+ // Cluster SampleManufacturerSpecific events
+ case MTREventIDTypeClusterSampleManufacturerSpecificEventPingCountEventID:
result = @"PingCountEvent";
break;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h
index 56423696e3dfeb..3efb57c825a981 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h
@@ -7456,16 +7456,16 @@ MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4))
@end
/**
- * Cluster Sample MEI
- * The Sample MEI cluster showcases a cluster manufacturer extensions
+ * Cluster Sample Manufacturer-Specific
+ * A manufacturer-specific sample cluster
*/
MTR_PROVISIONALLY_AVAILABLE
-@interface MTRClusterSampleMEI : MTRGenericCluster
+@interface MTRClusterSampleManufacturerSpecific : MTRGenericCluster
-- (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE;
+- (void)pingWithParams:(MTRSampleManufacturerSpecificClusterPingParams * _Nullable)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE;
- (void)pingWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion
MTR_PROVISIONALLY_AVAILABLE;
-- (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRSampleMEIClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE;
+- (void)addArgumentsWithParams:(MTRSampleManufacturerSpecificClusterAddArgumentsParams *)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE;
- (NSDictionary<NSString *, id> * _Nullable)readAttributeFlipFlopWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE;
- (void)writeAttributeFlipFlopWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE;
@@ -7486,7 +7486,7 @@ MTR_PROVISIONALLY_AVAILABLE
@end
-@interface MTRClusterSampleMEI (Availability)
+@interface MTRClusterSampleManufacturerSpecific (Availability)
/**
* For all instance methods that take a completion (i.e. command invocations),
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
index 908d6b385fd4bf..a849dc060c5b57 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
@@ -22778,16 +22778,16 @@ - (void)testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTes
}
@end
-@implementation MTRClusterSampleMEI
+@implementation MTRClusterSampleManufacturerSpecific
- (void)pingWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(MTRStatusCompletion)completion
{
[self pingWithParams:nil expectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs completion:completion];
}
-- (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion
+- (void)pingWithParams:(MTRSampleManufacturerSpecificClusterPingParams * _Nullable)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion
{
if (params == nil) {
- params = [[MTRSampleMEIClusterPingParams
+ params = [[MTRSampleManufacturerSpecificClusterPingParams
alloc] init];
}
@@ -22797,7 +22797,7 @@ - (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params expecte
auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
- using RequestType = SampleMei::Commands::Ping::Type;
+ using RequestType = SampleManufacturerSpecific::Commands::Ping::Type;
[self.device _invokeKnownCommandWithEndpointID:self.endpointID
clusterID:@(RequestType::GetClusterId())
commandID:@(RequestType::GetCommandId())
@@ -22811,10 +22811,10 @@ - (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params expecte
completion:responseHandler];
}
-- (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRSampleMEIClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion
+- (void)addArgumentsWithParams:(MTRSampleManufacturerSpecificClusterAddArgumentsParams *)params expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
if (params == nil) {
- params = [[MTRSampleMEIClusterAddArgumentsParams
+ params = [[MTRSampleManufacturerSpecificClusterAddArgumentsParams
alloc] init];
}
@@ -22824,7 +22824,7 @@ - (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params e
auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
- using RequestType = SampleMei::Commands::AddArguments::Type;
+ using RequestType = SampleManufacturerSpecific::Commands::AddArguments::Type;
[self.device _invokeKnownCommandWithEndpointID:self.endpointID
clusterID:@(RequestType::GetClusterId())
commandID:@(RequestType::GetCommandId())
@@ -22833,14 +22833,14 @@ - (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params e
expectedValueInterval:expectedValueIntervalMs
timedInvokeTimeout:timedInvokeTimeoutMs
serverSideProcessingTimeout:params.serverSideProcessingTimeout
- responseClass:MTRSampleMEIClusterAddArgumentsResponseParams.class
+ responseClass:MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams.class
queue:self.callbackQueue
completion:responseHandler];
}
- (NSDictionary<NSString *, id> * _Nullable)readAttributeFlipFlopWithParams:(MTRReadParams * _Nullable)params
{
- return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeFlipFlopID) params:params];
+ return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFlipFlopID) params:params];
}
- (void)writeAttributeFlipFlopWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs
@@ -22851,32 +22851,32 @@ - (void)writeAttributeFlipFlopWithValue:(NSDictionary<NSString *, id> *)dataValu
{
NSNumber * timedWriteTimeout = params.timedWriteTimeout;
- [self.device writeAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeFlipFlopID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout];
+ [self.device writeAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFlipFlopID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout];
}
- (NSDictionary<NSString *, id> * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
- return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeGeneratedCommandListID) params:params];
+ return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeGeneratedCommandListID) params:params];
}
- (NSDictionary<NSString *, id> * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
- return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeAcceptedCommandListID) params:params];
+ return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeAcceptedCommandListID) params:params];
}
- (NSDictionary<NSString *, id> * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
- return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeAttributeListID) params:params];
+ return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeAttributeListID) params:params];
}
- (NSDictionary<NSString *, id> * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
- return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeFeatureMapID) params:params];
+ return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeFeatureMapID) params:params];
}
- (NSDictionary<NSString *, id> * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
- return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleMEIID) attributeID:@(MTRAttributeIDTypeClusterSampleMEIAttributeClusterRevisionID) params:params];
+ return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeSampleManufacturerSpecificID) attributeID:@(MTRAttributeIDTypeClusterSampleManufacturerSpecificAttributeClusterRevisionID) params:params];
}
@end
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h
index 2677a33dedbcd7..98be1c6df287b7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h
@@ -14473,7 +14473,7 @@ MTR_PROVISIONALLY_AVAILABLE
@end
MTR_PROVISIONALLY_AVAILABLE
-@interface MTRSampleMEIClusterPingParams : NSObject <NSCopying>
+@interface MTRSampleManufacturerSpecificClusterPingParams : NSObject <NSCopying>
/**
* Controls whether the command is a timed command (using Timed Invoke).
*
@@ -14501,12 +14501,12 @@ MTR_PROVISIONALLY_AVAILABLE
@end
MTR_PROVISIONALLY_AVAILABLE
-@interface MTRSampleMEIClusterAddArgumentsResponseParams : NSObject <NSCopying>
+@interface MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams : NSObject <NSCopying>
@property (nonatomic, copy) NSNumber * _Nonnull returnValue MTR_PROVISIONALLY_AVAILABLE;
/**
- * Initialize an MTRSampleMEIClusterAddArgumentsResponseParams with a response-value dictionary
+ * Initialize an MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams with a response-value dictionary
* of the sort that MTRDeviceResponseHandler would receive.
*
* Will return nil and hand out an error if the response-value dictionary is not
@@ -14520,7 +14520,7 @@ MTR_PROVISIONALLY_AVAILABLE
@end
MTR_PROVISIONALLY_AVAILABLE
-@interface MTRSampleMEIClusterAddArgumentsParams : NSObject <NSCopying>
+@interface MTRSampleManufacturerSpecificClusterAddArgumentsParams : NSObject <NSCopying>
@property (nonatomic, copy) NSNumber * _Nonnull arg1 MTR_PROVISIONALLY_AVAILABLE;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm
index b56e51e21d1b06..16cc8d8227c7dc 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm
@@ -40512,7 +40512,7 @@ - (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::UnitTest
@end
-@implementation MTRSampleMEIClusterPingParams
+@implementation MTRSampleManufacturerSpecificClusterPingParams
- (instancetype)init
{
if (self = [super init]) {
@@ -40524,7 +40524,7 @@ - (instancetype)init
- (id)copyWithZone:(NSZone * _Nullable)zone;
{
- auto other = [[MTRSampleMEIClusterPingParams alloc] init];
+ auto other = [[MTRSampleManufacturerSpecificClusterPingParams alloc] init];
other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs;
other.serverSideProcessingTimeout = self.serverSideProcessingTimeout;
@@ -40540,11 +40540,11 @@ - (NSString *)description
@end
-@implementation MTRSampleMEIClusterPingParams (InternalMethods)
+@implementation MTRSampleManufacturerSpecificClusterPingParams (InternalMethods)
- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader
{
- chip::app::Clusters::SampleMei::Commands::Ping::Type encodableStruct;
+ chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::Type encodableStruct;
ListFreer listFreer;
auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0);
@@ -40585,7 +40585,7 @@ - (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader
}
@end
-@implementation MTRSampleMEIClusterAddArgumentsResponseParams
+@implementation MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams
- (instancetype)init
{
if (self = [super init]) {
@@ -40597,7 +40597,7 @@ - (instancetype)init
- (id)copyWithZone:(NSZone * _Nullable)zone;
{
- auto other = [[MTRSampleMEIClusterAddArgumentsResponseParams alloc] init];
+ auto other = [[MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams alloc] init];
other.returnValue = self.returnValue;
@@ -40617,7 +40617,7 @@ - (nullable instancetype)initWithResponseValue:(NSDictionary<NSString *, id> *)r
return nil;
}
- using DecodableType = chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::DecodableType;
+ using DecodableType = chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType;
chip::System::PacketBufferHandle buffer = [MTRBaseDevice _responseDataForCommand:responseValue
clusterID:DecodableType::GetClusterId()
commandID:DecodableType::GetCommandId()
@@ -40652,9 +40652,9 @@ - (nullable instancetype)initWithResponseValue:(NSDictionary<NSString *, id> *)r
@end
-@implementation MTRSampleMEIClusterAddArgumentsResponseParams (InternalMethods)
+@implementation MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams (InternalMethods)
-- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::DecodableType &)decodableStruct
+- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType &)decodableStruct
{
{
self.returnValue = [NSNumber numberWithUnsignedChar:decodableStruct.returnValue];
@@ -40664,7 +40664,7 @@ - (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::SampleMe
@end
-@implementation MTRSampleMEIClusterAddArgumentsParams
+@implementation MTRSampleManufacturerSpecificClusterAddArgumentsParams
- (instancetype)init
{
if (self = [super init]) {
@@ -40680,7 +40680,7 @@ - (instancetype)init
- (id)copyWithZone:(NSZone * _Nullable)zone;
{
- auto other = [[MTRSampleMEIClusterAddArgumentsParams alloc] init];
+ auto other = [[MTRSampleManufacturerSpecificClusterAddArgumentsParams alloc] init];
other.arg1 = self.arg1;
other.arg2 = self.arg2;
@@ -40698,11 +40698,11 @@ - (NSString *)description
@end
-@implementation MTRSampleMEIClusterAddArgumentsParams (InternalMethods)
+@implementation MTRSampleManufacturerSpecificClusterAddArgumentsParams (InternalMethods)
- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader
{
- chip::app::Clusters::SampleMei::Commands::AddArguments::Type encodableStruct;
+ chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Type encodableStruct;
ListFreer listFreer;
{
encodableStruct.arg1 = self.arg1.unsignedCharValue;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h
index 5ebfd4fc86cd5b..40260645e0daf5 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h
@@ -2524,19 +2524,19 @@ NS_ASSUME_NONNULL_BEGIN
@end
-@interface MTRSampleMEIClusterPingParams (InternalMethods)
+@interface MTRSampleManufacturerSpecificClusterPingParams (InternalMethods)
- (NSDictionary<NSString *, id> * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error;
@end
-@interface MTRSampleMEIClusterAddArgumentsResponseParams (InternalMethods)
+@interface MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams (InternalMethods)
-- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::DecodableType &)decodableStruct;
+- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType &)decodableStruct;
@end
-@interface MTRSampleMEIClusterAddArgumentsParams (InternalMethods)
+@interface MTRSampleManufacturerSpecificClusterAddArgumentsParams (InternalMethods)
- (NSDictionary<NSString *, id> * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm
index 08eaa8c4de9058..7a8c9ff80ad7ec 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm
@@ -1208,9 +1208,9 @@ static BOOL CommandNeedsTimedInvokeInUnitTestingCluster(AttributeId aAttributeId
}
}
}
-static BOOL CommandNeedsTimedInvokeInSampleMEICluster(AttributeId aAttributeId)
+static BOOL CommandNeedsTimedInvokeInSampleManufacturerSpecificCluster(AttributeId aAttributeId)
{
- using namespace Clusters::SampleMei;
+ using namespace Clusters::SampleManufacturerSpecific;
switch (aAttributeId) {
default: {
return NO;
@@ -1593,8 +1593,8 @@ BOOL MTRCommandNeedsTimedInvoke(NSNumber * _Nonnull aClusterID, NSNumber * _Nonn
case Clusters::UnitTesting::Id: {
return CommandNeedsTimedInvokeInUnitTestingCluster(commandID);
}
- case Clusters::SampleMei::Id: {
- return CommandNeedsTimedInvokeInSampleMEICluster(commandID);
+ case Clusters::SampleManufacturerSpecific::Id: {
+ return CommandNeedsTimedInvokeInSampleManufacturerSpecificCluster(commandID);
}
default: {
return NO;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm
index ce51877b7b99bd..8818e789cea5cc 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm
@@ -5156,9 +5156,9 @@ static id _Nullable DecodeEventPayloadForUnitTestingCluster(EventId aEventId, TL
*aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
return nil;
}
-static id _Nullable DecodeEventPayloadForSampleMEICluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
+static id _Nullable DecodeEventPayloadForSampleManufacturerSpecificCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
{
- using namespace Clusters::SampleMei;
+ using namespace Clusters::SampleManufacturerSpecific;
switch (aEventId) {
case Events::PingCountEvent::Id: {
Events::PingCountEvent::DecodableType cppValue;
@@ -5167,7 +5167,7 @@ static id _Nullable DecodeEventPayloadForSampleMEICluster(EventId aEventId, TLV:
return nil;
}
- __auto_type * value = [MTRSampleMEIClusterPingCountEventEvent new];
+ __auto_type * value = [MTRSampleManufacturerSpecificClusterPingCountEventEvent new];
do {
NSNumber * _Nonnull memberValue;
@@ -5563,8 +5563,8 @@ id _Nullable MTRDecodeEventPayload(const ConcreteEventPath & aPath, TLV::TLVRead
case Clusters::UnitTesting::Id: {
return DecodeEventPayloadForUnitTestingCluster(aPath.mEventId, aReader, aError);
}
- case Clusters::SampleMei::Id: {
- return DecodeEventPayloadForSampleMEICluster(aPath.mEventId, aReader, aError);
+ case Clusters::SampleManufacturerSpecific::Id: {
+ return DecodeEventPayloadForSampleManufacturerSpecificCluster(aPath.mEventId, aReader, aError);
}
default: {
break;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h
index 412864bc77ea89..e1ec2e3c13c747 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h
@@ -2559,7 +2559,7 @@ MTR_PROVISIONALLY_AVAILABLE
@end
MTR_PROVISIONALLY_AVAILABLE
-@interface MTRSampleMEIClusterPingCountEventEvent : NSObject <NSCopying>
+@interface MTRSampleManufacturerSpecificClusterPingCountEventEvent : NSObject <NSCopying>
@property (nonatomic, copy, getter=getCount) NSNumber * _Nonnull count MTR_PROVISIONALLY_AVAILABLE;
@property (nonatomic, copy) NSNumber * _Nonnull fabricIndex MTR_PROVISIONALLY_AVAILABLE;
@end
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm
index 903a3077814cdc..27c595c4f78331 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm
@@ -10394,7 +10394,7 @@ - (NSString *)description
@end
-@implementation MTRSampleMEIClusterPingCountEventEvent
+@implementation MTRSampleManufacturerSpecificClusterPingCountEventEvent
- (instancetype)init
{
if (self = [super init]) {
@@ -10408,7 +10408,7 @@ - (instancetype)init
- (id)copyWithZone:(NSZone * _Nullable)zone
{
- auto other = [[MTRSampleMEIClusterPingCountEventEvent alloc] init];
+ auto other = [[MTRSampleManufacturerSpecificClusterPingCountEventEvent alloc] init];
other.count = self.count;
other.fabricIndex = self.fabricIndex;
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
index acb1d4e6381227..d048ba009d8d33 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
@@ -44413,7 +44413,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
} // namespace Attributes
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Attributes {
namespace FlipFlop {
@@ -44424,7 +44424,7 @@ Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value)
Traits::StorageType temp;
uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
Protocols::InteractionModel::Status status =
- emberAfReadAttribute(endpoint, Clusters::SampleMei::Id, Id, readable, sizeof(temp));
+ emberAfReadAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, readable, sizeof(temp));
VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
{
@@ -44444,7 +44444,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAtt
Traits::StorageType storageValue;
Traits::WorkingToStorage(value, storageValue);
uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
- return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleMei::Id, Id),
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleManufacturerSpecific::Id, Id),
EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
}
@@ -44458,7 +44458,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value)
Traits::StorageType storageValue;
Traits::WorkingToStorage(value, storageValue);
uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
- return emberAfWriteAttribute(endpoint, Clusters::SampleMei::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
}
} // namespace FlipFlop
@@ -44471,7 +44471,7 @@ Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value)
Traits::StorageType temp;
uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
Protocols::InteractionModel::Status status =
- emberAfReadAttribute(endpoint, Clusters::SampleMei::Id, Id, readable, sizeof(temp));
+ emberAfReadAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, readable, sizeof(temp));
VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
{
@@ -44491,7 +44491,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value, Mar
Traits::StorageType storageValue;
Traits::WorkingToStorage(value, storageValue);
uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
- return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleMei::Id, Id),
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleManufacturerSpecific::Id, Id),
EmberAfWriteDataInput(writable, ZCL_BITMAP32_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
}
@@ -44505,7 +44505,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value)
Traits::StorageType storageValue;
Traits::WorkingToStorage(value, storageValue);
uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
- return emberAfWriteAttribute(endpoint, Clusters::SampleMei::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
}
} // namespace FeatureMap
@@ -44518,7 +44518,7 @@ Protocols::InteractionModel::Status Get(EndpointId endpoint, uint16_t * value)
Traits::StorageType temp;
uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
Protocols::InteractionModel::Status status =
- emberAfReadAttribute(endpoint, Clusters::SampleMei::Id, Id, readable, sizeof(temp));
+ emberAfReadAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, readable, sizeof(temp));
VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status);
if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
{
@@ -44538,7 +44538,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, Mar
Traits::StorageType storageValue;
Traits::WorkingToStorage(value, storageValue);
uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
- return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleMei::Id, Id),
+ return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::SampleManufacturerSpecific::Id, Id),
EmberAfWriteDataInput(writable, ZCL_INT16U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty));
}
@@ -44552,13 +44552,13 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value)
Traits::StorageType storageValue;
Traits::WorkingToStorage(value, storageValue);
uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
- return emberAfWriteAttribute(endpoint, Clusters::SampleMei::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+ return emberAfWriteAttribute(endpoint, Clusters::SampleManufacturerSpecific::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
}
} // namespace ClusterRevision
} // namespace Attributes
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
index 861229005612ea..fc36256d8df93f 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
@@ -6649,7 +6649,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, Mar
} // namespace Attributes
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Attributes {
namespace FlipFlop {
@@ -6671,7 +6671,7 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, Mar
} // namespace ClusterRevision
} // namespace Attributes
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h
index 35c7efe18b98cf..7123c4f9d94007 100644
--- a/zzz_generated/app-common/app-common/zap-generated/callback.h
+++ b/zzz_generated/app-common/app-common/zap-generated/callback.h
@@ -671,7 +671,7 @@ void emberAfFaultInjectionClusterInitCallback(chip::EndpointId endpoint);
/**
* @param endpoint Endpoint that is being initialized
*/
-void emberAfSampleMeiClusterInitCallback(chip::EndpointId endpoint);
+void emberAfSampleManufacturerSpecificClusterInitCallback(chip::EndpointId endpoint);
// Cluster Server/Client Init Functions
@@ -5583,28 +5583,28 @@ MatterFaultInjectionClusterServerPreAttributeChangedCallback(const chip::app::Co
void emberAfFaultInjectionClusterServerTickCallback(chip::EndpointId endpoint);
//
-// Sample MEI Cluster
+// Sample Manufacturer-Specific Cluster
//
/**
* @param endpoint Endpoint that is being initialized
*/
-void emberAfSampleMeiClusterServerInitCallback(chip::EndpointId endpoint);
+void emberAfSampleManufacturerSpecificClusterServerInitCallback(chip::EndpointId endpoint);
/**
* @param endpoint Endpoint that is being shutdown
*/
-void MatterSampleMeiClusterServerShutdownCallback(chip::EndpointId endpoint);
+void MatterSampleManufacturerSpecificClusterServerShutdownCallback(chip::EndpointId endpoint);
/**
* @param endpoint Endpoint that is being initialized
*/
-void emberAfSampleMeiClusterClientInitCallback(chip::EndpointId endpoint);
+void emberAfSampleManufacturerSpecificClusterClientInitCallback(chip::EndpointId endpoint);
/**
* @param attributePath Concrete attribute path that changed
*/
-void MatterSampleMeiClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+void MatterSampleManufacturerSpecificClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
/**
* @param attributePath Concrete attribute path to be changed
@@ -5612,14 +5612,13 @@ void MatterSampleMeiClusterServerAttributeChangedCallback(const chip::app::Concr
* @param size Attribute size
* @param value Attribute value
*/
-chip::Protocols::InteractionModel::Status
-MatterSampleMeiClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
- EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+chip::Protocols::InteractionModel::Status MatterSampleManufacturerSpecificClusterServerPreAttributeChangedCallback(
+ const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
/**
* @param endpoint Endpoint that is being served
*/
-void emberAfSampleMeiClusterServerTickCallback(chip::EndpointId endpoint);
+void emberAfSampleManufacturerSpecificClusterServerTickCallback(chip::EndpointId endpoint);
// Cluster Commands Callback
diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h
index 9158953177e6cc..02eb8edcae0c56 100644
--- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h
+++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h
@@ -5735,7 +5735,7 @@ enum class FaultType : uint8_t
};
} // namespace FaultInjection
-namespace SampleMei {} // namespace SampleMei
+namespace SampleManufacturerSpecific {} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
index ccc6e6041a7de4..4750ed8816a031 100644
--- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
+++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp
@@ -34485,7 +34485,7 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre
namespace Events {} // namespace Events
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Commands {
namespace Ping {
@@ -34649,7 +34649,7 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
} // namespace PingCountEvent.
} // namespace Events
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
@@ -35373,7 +35373,7 @@ bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand)
return false;
}
}
- case Clusters::SampleMei::Id: {
+ case Clusters::SampleManufacturerSpecific::Id: {
switch (aCommand)
{
default:
diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
index 8eaa141995b304..0709715e791dd2 100644
--- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
+++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h
@@ -47829,7 +47829,7 @@ struct TypeInfo
};
} // namespace Attributes
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Commands {
// Forward-declarations so we can reference these later.
@@ -47862,7 +47862,7 @@ struct Type
public:
// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
static constexpr CommandId GetCommandId() { return Commands::Ping::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
@@ -47875,7 +47875,7 @@ struct DecodableType
{
public:
static constexpr CommandId GetCommandId() { return Commands::Ping::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
CHIP_ERROR Decode(TLV::TLVReader & reader);
};
@@ -47891,7 +47891,7 @@ struct Type
public:
// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
static constexpr CommandId GetCommandId() { return Commands::AddArgumentsResponse::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
uint8_t returnValue = static_cast<uint8_t>(0);
@@ -47906,7 +47906,7 @@ struct DecodableType
{
public:
static constexpr CommandId GetCommandId() { return Commands::AddArgumentsResponse::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
uint8_t returnValue = static_cast<uint8_t>(0);
CHIP_ERROR Decode(TLV::TLVReader & reader);
@@ -47924,14 +47924,14 @@ struct Type
public:
// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
static constexpr CommandId GetCommandId() { return Commands::AddArguments::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
uint8_t arg1 = static_cast<uint8_t>(0);
uint8_t arg2 = static_cast<uint8_t>(0);
CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
- using ResponseType = Clusters::SampleMei::Commands::AddArgumentsResponse::DecodableType;
+ using ResponseType = Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType;
static constexpr bool MustUseTimedInvoke() { return false; }
};
@@ -47940,7 +47940,7 @@ struct DecodableType
{
public:
static constexpr CommandId GetCommandId() { return Commands::AddArguments::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
uint8_t arg1 = static_cast<uint8_t>(0);
uint8_t arg2 = static_cast<uint8_t>(0);
@@ -47958,7 +47958,7 @@ struct TypeInfo
using DecodableType = bool;
using DecodableArgType = bool;
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
static constexpr AttributeId GetAttributeId() { return Attributes::FlipFlop::Id; }
static constexpr bool MustUseTimedWrite() { return false; }
};
@@ -47966,31 +47966,31 @@ struct TypeInfo
namespace GeneratedCommandList {
struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
{
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
};
} // namespace GeneratedCommandList
namespace AcceptedCommandList {
struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
{
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
};
} // namespace AcceptedCommandList
namespace AttributeList {
struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
{
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
};
} // namespace AttributeList
namespace FeatureMap {
struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
{
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
};
} // namespace FeatureMap
namespace ClusterRevision {
struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
{
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
};
} // namespace ClusterRevision
@@ -47998,7 +47998,7 @@ struct TypeInfo
{
struct DecodableType
{
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
@@ -48026,7 +48026,7 @@ struct Type
public:
static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
static constexpr EventId GetEventId() { return Events::PingCountEvent::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
static constexpr bool kIsFabricScoped = true;
uint32_t count = static_cast<uint32_t>(0);
@@ -48042,7 +48042,7 @@ struct DecodableType
public:
static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
static constexpr EventId GetEventId() { return Events::PingCountEvent::Id; }
- static constexpr ClusterId GetClusterId() { return Clusters::SampleMei::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::SampleManufacturerSpecific::Id; }
uint32_t count = static_cast<uint32_t>(0);
chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0);
@@ -48051,7 +48051,7 @@ struct DecodableType
};
} // namespace PingCountEvent
} // namespace Events
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
index ca4444aa83cee5..06b6135130cb82 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
@@ -7685,7 +7685,7 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
} // namespace Attributes
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Attributes {
namespace FlipFlop {
@@ -7713,7 +7713,7 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
} // namespace ClusterRevision
} // namespace Attributes
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
index a9e3fad362a4ae..e4ccb8b5824799 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
@@ -406,9 +406,9 @@ static constexpr ClusterId Id = 0xFFF1FC05;
namespace FaultInjection {
static constexpr ClusterId Id = 0xFFF1FC06;
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
static constexpr ClusterId Id = 0xFFF1FC20;
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
index 40954ab0ea5f29..71e64111a205b5 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
@@ -2201,7 +2201,7 @@ static constexpr CommandId Id = 0x00000001;
} // namespace Commands
} // namespace FaultInjection
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Commands {
namespace Ping {
@@ -2217,7 +2217,7 @@ static constexpr CommandId Id = 0x00000002;
} // namespace AddArguments
} // namespace Commands
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h
index 818b5504b29e30..369f653cd863cc 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h
@@ -743,7 +743,7 @@ static constexpr EventId Id = 0xFFF200EE;
} // namespace Events
} // namespace UnitTesting
-namespace SampleMei {
+namespace SampleManufacturerSpecific {
namespace Events {
namespace PingCountEvent {
@@ -751,7 +751,7 @@ static constexpr EventId Id = 0x00000000;
} // namespace PingCountEvent
} // namespace Events
-} // namespace SampleMei
+} // namespace SampleManufacturerSpecific
} // namespace Clusters
} // namespace app
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
index c2df08e2957dfc..0fe40c15b7a220 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
@@ -162,7 +162,7 @@
| CommissionerControl | 0x0751 |
| UnitTesting | 0xFFF1FC05|
| FaultInjection | 0xFFF1FC06|
-| SampleMei | 0xFFF1FC20|
+| SampleManufacturerSpecific | 0xFFF1FC20|
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
@@ -16372,7 +16372,7 @@ class FaultInjectionFailRandomlyAtFault : public ClusterCommand
};
/*----------------------------------------------------------------------------*\
-| Cluster SampleMei | 0xFFF1FC20 |
+| Cluster SampleManufacturerSpecific | 0xFFF1FC20 |
|------------------------------------------------------------------------------|
| Commands: | |
| * Ping | 0x00 |
@@ -16393,18 +16393,18 @@ class FaultInjectionFailRandomlyAtFault : public ClusterCommand
/*
* Command Ping
*/
-class SampleMeiPing : public ClusterCommand
+class SampleManufacturerSpecificPing : public ClusterCommand
{
public:
- SampleMeiPing(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("ping", credsIssuerConfig)
+ SampleManufacturerSpecificPing(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("ping", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::Ping::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId commandId = chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
commandId, endpointIds.at(0));
@@ -16413,8 +16413,8 @@ class SampleMeiPing : public ClusterCommand
CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::Ping::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId commandId = chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
groupId);
@@ -16423,16 +16423,17 @@ class SampleMeiPing : public ClusterCommand
}
private:
- chip::app::Clusters::SampleMei::Commands::Ping::Type mRequest;
+ chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::Type mRequest;
};
/*
* Command AddArguments
*/
-class SampleMeiAddArguments : public ClusterCommand
+class SampleManufacturerSpecificAddArguments : public ClusterCommand
{
public:
- SampleMeiAddArguments(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-arguments", credsIssuerConfig)
+ SampleManufacturerSpecificAddArguments(CredentialIssuerCommands * credsIssuerConfig) :
+ ClusterCommand("add-arguments", credsIssuerConfig)
{
AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
@@ -16441,8 +16442,8 @@ class SampleMeiAddArguments : public ClusterCommand
CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::AddArguments::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId commandId = chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
commandId, endpointIds.at(0));
@@ -16451,8 +16452,8 @@ class SampleMeiAddArguments : public ClusterCommand
CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::AddArguments::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId commandId = chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
groupId);
@@ -16461,7 +16462,7 @@ class SampleMeiAddArguments : public ClusterCommand
}
private:
- chip::app::Clusters::SampleMei::Commands::AddArguments::Type mRequest;
+ chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Type mRequest;
};
/*----------------------------------------------------------------------------*\
@@ -28220,19 +28221,19 @@ void registerClusterFaultInjection(Commands & commands, CredentialIssuerCommands
commands.RegisterCluster(clusterName, clusterCommands);
}
-void registerClusterSampleMei(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
+void registerClusterSampleManufacturerSpecific(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
- using namespace chip::app::Clusters::SampleMei;
+ using namespace chip::app::Clusters::SampleManufacturerSpecific;
- const char * clusterName = "SampleMei";
+ const char * clusterName = "SampleManufacturerSpecific";
commands_list clusterCommands = {
//
// Commands
//
- make_unique<ClusterCommand>(Id, credsIssuerConfig), //
- make_unique<SampleMeiPing>(credsIssuerConfig), //
- make_unique<SampleMeiAddArguments>(credsIssuerConfig), //
+ make_unique<ClusterCommand>(Id, credsIssuerConfig), //
+ make_unique<SampleManufacturerSpecificPing>(credsIssuerConfig), //
+ make_unique<SampleManufacturerSpecificAddArguments>(credsIssuerConfig), //
//
// Attributes
//
@@ -28427,5 +28428,5 @@ void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssue
registerClusterCommissionerControl(commands, credsIssuerConfig);
registerClusterUnitTesting(commands, credsIssuerConfig);
registerClusterFaultInjection(commands, credsIssuerConfig);
- registerClusterSampleMei(commands, credsIssuerConfig);
+ registerClusterSampleManufacturerSpecific(commands, credsIssuerConfig);
}
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp
index 258181b9144387..b729c95092a7e0 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp
+++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp
@@ -9144,7 +9144,7 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent,
return CHIP_NO_ERROR;
}
CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent,
- const SampleMei::Events::PingCountEvent::DecodableType & value)
+ const SampleManufacturerSpecific::Events::PingCountEvent::DecodableType & value)
{
DataModelLogger::LogString(label, indent, "{");
{
@@ -10093,7 +10093,7 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent,
return CHIP_NO_ERROR;
}
CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent,
- const SampleMei::Commands::AddArgumentsResponse::DecodableType & value)
+ const SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType & value)
{
DataModelLogger::LogString(label, indent, "{");
ReturnErrorOnFailure(DataModelLogger::LogValue("returnValue", indent + 1, value.returnValue));
@@ -19592,35 +19592,35 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP
}
break;
}
- case SampleMei::Id: {
+ case SampleManufacturerSpecific::Id: {
switch (path.mAttributeId)
{
- case SampleMei::Attributes::FlipFlop::Id: {
+ case SampleManufacturerSpecific::Attributes::FlipFlop::Id: {
bool value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
return DataModelLogger::LogValue("FlipFlop", 1, value);
}
- case SampleMei::Attributes::GeneratedCommandList::Id: {
+ case SampleManufacturerSpecific::Attributes::GeneratedCommandList::Id: {
chip::app::DataModel::DecodableList<chip::CommandId> value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
- return DataModelLogger::LogGeneratedCommandId("GeneratedCommandList", 1, value, SampleMei::Id);
+ return DataModelLogger::LogGeneratedCommandId("GeneratedCommandList", 1, value, SampleManufacturerSpecific::Id);
}
- case SampleMei::Attributes::AcceptedCommandList::Id: {
+ case SampleManufacturerSpecific::Attributes::AcceptedCommandList::Id: {
chip::app::DataModel::DecodableList<chip::CommandId> value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
- return DataModelLogger::LogAcceptedCommandId("AcceptedCommandList", 1, value, SampleMei::Id);
+ return DataModelLogger::LogAcceptedCommandId("AcceptedCommandList", 1, value, SampleManufacturerSpecific::Id);
}
- case SampleMei::Attributes::AttributeList::Id: {
+ case SampleManufacturerSpecific::Attributes::AttributeList::Id: {
chip::app::DataModel::DecodableList<chip::AttributeId> value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
- return DataModelLogger::LogAttributeId("AttributeList", 1, value, SampleMei::Id);
+ return DataModelLogger::LogAttributeId("AttributeList", 1, value, SampleManufacturerSpecific::Id);
}
- case SampleMei::Attributes::FeatureMap::Id: {
+ case SampleManufacturerSpecific::Attributes::FeatureMap::Id: {
uint32_t value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
return DataModelLogger::LogValue("FeatureMap", 1, value);
}
- case SampleMei::Attributes::ClusterRevision::Id: {
+ case SampleManufacturerSpecific::Attributes::ClusterRevision::Id: {
uint16_t value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
return DataModelLogger::LogValue("ClusterRevision", 1, value);
@@ -20387,11 +20387,11 @@ CHIP_ERROR DataModelLogger::LogCommand(const chip::app::ConcreteCommandPath & pa
}
break;
}
- case SampleMei::Id: {
+ case SampleManufacturerSpecific::Id: {
switch (path.mCommandId)
{
- case SampleMei::Commands::AddArgumentsResponse::Id: {
- SampleMei::Commands::AddArgumentsResponse::DecodableType value;
+ case SampleManufacturerSpecific::Commands::AddArgumentsResponse::Id: {
+ SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
return DataModelLogger::LogValue("AddArgumentsResponse", 1, value);
}
@@ -21272,11 +21272,11 @@ CHIP_ERROR DataModelLogger::LogEvent(const chip::app::EventHeader & header, chip
}
break;
}
- case SampleMei::Id: {
+ case SampleManufacturerSpecific::Id: {
switch (header.mPath.mEventId)
{
- case SampleMei::Events::PingCountEvent::Id: {
- chip::app::Clusters::SampleMei::Events::PingCountEvent::DecodableType value;
+ case SampleManufacturerSpecific::Events::PingCountEvent::Id: {
+ chip::app::Clusters::SampleManufacturerSpecific::Events::PingCountEvent::DecodableType value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
return DataModelLogger::LogValue("PingCountEvent", 1, value);
}
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h
index 95434280b5521f..f78f1a7aabd0f3 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h
@@ -755,7 +755,7 @@ static CHIP_ERROR LogValue(const char * label, size_t indent,
static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::UnitTesting::Events::TestDifferentVendorMeiEvent::DecodableType & value);
static CHIP_ERROR LogValue(const char * label, size_t indent,
- const chip::app::Clusters::SampleMei::Events::PingCountEvent::DecodableType & value);
+ const chip::app::Clusters::SampleManufacturerSpecific::Events::PingCountEvent::DecodableType & value);
static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::Groups::Commands::AddGroupResponse::DecodableType & value);
@@ -979,5 +979,6 @@ static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::UnitTesting::Commands::GlobalEchoResponse::DecodableType & value);
static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::UnitTesting::Commands::TestDifferentVendorMeiResponse::DecodableType & value);
-static CHIP_ERROR LogValue(const char * label, size_t indent,
- const chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::DecodableType & value);
+static CHIP_ERROR
+LogValue(const char * label, size_t indent,
+ const chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::DecodableType & value);
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/EntryToText.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/EntryToText.cpp
index 1994301e279689..8554adf797f993 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/logging/EntryToText.cpp
+++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/EntryToText.cpp
@@ -279,8 +279,8 @@ char const * ClusterIdToText(chip::ClusterId id)
return "UnitTesting";
case chip::app::Clusters::FaultInjection::Id:
return "FaultInjection";
- case chip::app::Clusters::SampleMei::Id:
- return "SampleMei";
+ case chip::app::Clusters::SampleManufacturerSpecific::Id:
+ return "SampleManufacturerSpecific";
default:
return "Unknown";
}
@@ -4615,20 +4615,20 @@ char const * AttributeIdToText(chip::ClusterId cluster, chip::AttributeId id)
return "Unknown";
}
}
- case chip::app::Clusters::SampleMei::Id: {
+ case chip::app::Clusters::SampleManufacturerSpecific::Id: {
switch (id)
{
- case chip::app::Clusters::SampleMei::Attributes::FlipFlop::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Attributes::FlipFlop::Id:
return "FlipFlop";
- case chip::app::Clusters::SampleMei::Attributes::GeneratedCommandList::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Attributes::GeneratedCommandList::Id:
return "GeneratedCommandList";
- case chip::app::Clusters::SampleMei::Attributes::AcceptedCommandList::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Attributes::AcceptedCommandList::Id:
return "AcceptedCommandList";
- case chip::app::Clusters::SampleMei::Attributes::AttributeList::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Attributes::AttributeList::Id:
return "AttributeList";
- case chip::app::Clusters::SampleMei::Attributes::FeatureMap::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Attributes::FeatureMap::Id:
return "FeatureMap";
- case chip::app::Clusters::SampleMei::Attributes::ClusterRevision::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Attributes::ClusterRevision::Id:
return "ClusterRevision";
default:
return "Unknown";
@@ -5864,12 +5864,12 @@ char const * AcceptedCommandIdToText(chip::ClusterId cluster, chip::CommandId id
return "Unknown";
}
}
- case chip::app::Clusters::SampleMei::Id: {
+ case chip::app::Clusters::SampleManufacturerSpecific::Id: {
switch (id)
{
- case chip::app::Clusters::SampleMei::Commands::Ping::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::Id:
return "Ping";
- case chip::app::Clusters::SampleMei::Commands::AddArguments::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Id:
return "AddArguments";
default:
return "Unknown";
@@ -6389,10 +6389,10 @@ char const * GeneratedCommandIdToText(chip::ClusterId cluster, chip::CommandId i
return "Unknown";
}
}
- case chip::app::Clusters::SampleMei::Id: {
+ case chip::app::Clusters::SampleManufacturerSpecific::Id: {
switch (id)
{
- case chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::Id:
+ case chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::Id:
return "AddArgumentsResponse";
default:
return "Unknown";
diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h
index 2d61cb58b2f359..49b8635abc4b8a 100644
--- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h
@@ -164,7 +164,7 @@
| CommissionerControl | 0x0751 |
| UnitTesting | 0xFFF1FC05|
| FaultInjection | 0xFFF1FC06|
-| SampleMei | 0xFFF1FC20|
+| SampleManufacturerSpecific | 0xFFF1FC20|
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
@@ -173865,7 +173865,7 @@ class SubscribeAttributeUnitTestingMeiInt8u : public SubscribeAttribute {
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
/*----------------------------------------------------------------------------*\
-| Cluster SampleMei | 0xFFF1FC20 |
+| Cluster SampleManufacturerSpecific | 0xFFF1FC20 |
|------------------------------------------------------------------------------|
| Commands: | |
| * Ping | 0x00 |
@@ -173887,9 +173887,9 @@ class SubscribeAttributeUnitTestingMeiInt8u : public SubscribeAttribute {
/*
* Command Ping
*/
-class SampleMeiPing : public ClusterCommand {
+class SampleManufacturerSpecificPing : public ClusterCommand {
public:
- SampleMeiPing()
+ SampleManufacturerSpecificPing()
: ClusterCommand("ping")
{
ClusterCommand::AddArguments();
@@ -173897,14 +173897,14 @@ class SampleMeiPing : public ClusterCommand {
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::Ping::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId commandId = chip::app::Clusters::SampleManufacturerSpecific::Commands::Ping::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
- __auto_type * params = [[MTRSampleMEIClusterPingParams alloc] init];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * params = [[MTRSampleManufacturerSpecificClusterPingParams alloc] init];
params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil;
uint16_t repeatCount = mRepeatCount.ValueOr(1);
uint16_t __block responsesNeeded = repeatCount;
@@ -173933,9 +173933,9 @@ class SampleMeiPing : public ClusterCommand {
/*
* Command AddArguments
*/
-class SampleMeiAddArguments : public ClusterCommand {
+class SampleManufacturerSpecificAddArguments : public ClusterCommand {
public:
- SampleMeiAddArguments()
+ SampleManufacturerSpecificAddArguments()
: ClusterCommand("add-arguments")
{
#if MTR_ENABLE_PROVISIONAL
@@ -173949,14 +173949,14 @@ class SampleMeiAddArguments : public ClusterCommand {
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::AddArguments::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId commandId = chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
- __auto_type * params = [[MTRSampleMEIClusterAddArgumentsParams alloc] init];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * params = [[MTRSampleManufacturerSpecificClusterAddArgumentsParams alloc] init];
params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil;
#if MTR_ENABLE_PROVISIONAL
params.arg1 = [NSNumber numberWithUnsignedChar:mRequest.arg1];
@@ -173968,17 +173968,17 @@ class SampleMeiAddArguments : public ClusterCommand {
uint16_t __block responsesNeeded = repeatCount;
while (repeatCount--) {
[cluster addArgumentsWithParams:params completion:
- ^(MTRSampleMEIClusterAddArgumentsResponseParams * _Nullable values, NSError * _Nullable error) {
+ ^(MTRSampleManufacturerSpecificClusterAddArgumentsResponseParams * _Nullable values, NSError * _Nullable error) {
NSLog(@"Values: %@", values);
if (error == nil) {
- constexpr chip::CommandId responseId = chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::Id;
+ constexpr chip::CommandId responseId = chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::Id;
RemoteDataModelLogger::LogCommandAsJSON(@(endpointId), @(clusterId), @(responseId), values);
}
responsesNeeded--;
if (error != nil) {
mError = error;
LogNSError("Error", error);
- constexpr chip::CommandId responseId = chip::app::Clusters::SampleMei::Commands::AddArgumentsResponse::Id;
+ constexpr chip::CommandId responseId = chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArgumentsResponse::Id;
RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(responseId), error);
}
if (responsesNeeded == 0) {
@@ -173990,7 +173990,7 @@ class SampleMeiAddArguments : public ClusterCommand {
}
private:
- chip::app::Clusters::SampleMei::Commands::AddArguments::Type mRequest;
+ chip::app::Clusters::SampleManufacturerSpecific::Commands::AddArguments::Type mRequest;
};
#endif // MTR_ENABLE_PROVISIONAL
@@ -174000,32 +174000,32 @@ class SampleMeiAddArguments : public ClusterCommand {
/*
* Attribute FlipFlop
*/
-class ReadSampleMeiFlipFlop : public ReadAttribute {
+class ReadSampleManufacturerSpecificFlipFlop : public ReadAttribute {
public:
- ReadSampleMeiFlipFlop()
+ ReadSampleManufacturerSpecificFlipFlop()
: ReadAttribute("flip-flop")
{
}
- ~ReadSampleMeiFlipFlop()
+ ~ReadSampleManufacturerSpecificFlipFlop()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::FlipFlop::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::FlipFlop::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
[cluster readAttributeFlipFlopWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.FlipFlop response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.FlipFlop response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
- LogNSError("SampleMEI FlipFlop read Error", error);
+ LogNSError("SampleManufacturerSpecific FlipFlop read Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174034,9 +174034,9 @@ class ReadSampleMeiFlipFlop : public ReadAttribute {
}
};
-class WriteSampleMeiFlipFlop : public WriteAttribute {
+class WriteSampleManufacturerSpecificFlipFlop : public WriteAttribute {
public:
- WriteSampleMeiFlipFlop()
+ WriteSampleManufacturerSpecificFlipFlop()
: WriteAttribute("flip-flop")
{
AddArgument("attr-name", "flip-flop");
@@ -174044,18 +174044,18 @@ class WriteSampleMeiFlipFlop : public WriteAttribute {
WriteAttribute::AddArguments();
}
- ~WriteSampleMeiFlipFlop()
+ ~WriteSampleManufacturerSpecificFlipFlop()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::FlipFlop::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::FlipFlop::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") WriteAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRWriteParams alloc] init];
params.timedWriteTimeout = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil;
params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil;
@@ -174063,7 +174063,7 @@ class WriteSampleMeiFlipFlop : public WriteAttribute {
[cluster writeAttributeFlipFlopWithValue:value params:params completion:^(NSError * _Nullable error) {
if (error != nil) {
- LogNSError("SampleMEI FlipFlop write Error", error);
+ LogNSError("SampleManufacturerSpecific FlipFlop write Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174075,25 +174075,25 @@ class WriteSampleMeiFlipFlop : public WriteAttribute {
bool mValue;
};
-class SubscribeAttributeSampleMeiFlipFlop : public SubscribeAttribute {
+class SubscribeAttributeSampleManufacturerSpecificFlipFlop : public SubscribeAttribute {
public:
- SubscribeAttributeSampleMeiFlipFlop()
+ SubscribeAttributeSampleManufacturerSpecificFlipFlop()
: SubscribeAttribute("flip-flop")
{
}
- ~SubscribeAttributeSampleMeiFlipFlop()
+ ~SubscribeAttributeSampleManufacturerSpecificFlipFlop()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId attributeId = chip::app::Clusters::SampleMei::Attributes::FlipFlop::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::FlipFlop::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
if (mKeepSubscriptions.HasValue()) {
params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
@@ -174107,7 +174107,7 @@ class SubscribeAttributeSampleMeiFlipFlop : public SubscribeAttribute {
[cluster subscribeAttributeFlipFlopWithParams:params
subscriptionEstablished:^() { mSubscriptionEstablished = YES; }
reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.FlipFlop response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.FlipFlop response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
@@ -174126,32 +174126,32 @@ class SubscribeAttributeSampleMeiFlipFlop : public SubscribeAttribute {
/*
* Attribute GeneratedCommandList
*/
-class ReadSampleMeiGeneratedCommandList : public ReadAttribute {
+class ReadSampleManufacturerSpecificGeneratedCommandList : public ReadAttribute {
public:
- ReadSampleMeiGeneratedCommandList()
+ ReadSampleManufacturerSpecificGeneratedCommandList()
: ReadAttribute("generated-command-list")
{
}
- ~ReadSampleMeiGeneratedCommandList()
+ ~ReadSampleManufacturerSpecificGeneratedCommandList()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::GeneratedCommandList::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::GeneratedCommandList::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
[cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.GeneratedCommandList response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.GeneratedCommandList response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
- LogNSError("SampleMEI GeneratedCommandList read Error", error);
+ LogNSError("SampleManufacturerSpecific GeneratedCommandList read Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174160,25 +174160,25 @@ class ReadSampleMeiGeneratedCommandList : public ReadAttribute {
}
};
-class SubscribeAttributeSampleMeiGeneratedCommandList : public SubscribeAttribute {
+class SubscribeAttributeSampleManufacturerSpecificGeneratedCommandList : public SubscribeAttribute {
public:
- SubscribeAttributeSampleMeiGeneratedCommandList()
+ SubscribeAttributeSampleManufacturerSpecificGeneratedCommandList()
: SubscribeAttribute("generated-command-list")
{
}
- ~SubscribeAttributeSampleMeiGeneratedCommandList()
+ ~SubscribeAttributeSampleManufacturerSpecificGeneratedCommandList()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId attributeId = chip::app::Clusters::SampleMei::Attributes::GeneratedCommandList::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::GeneratedCommandList::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
if (mKeepSubscriptions.HasValue()) {
params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
@@ -174192,7 +174192,7 @@ class SubscribeAttributeSampleMeiGeneratedCommandList : public SubscribeAttribut
[cluster subscribeAttributeGeneratedCommandListWithParams:params
subscriptionEstablished:^() { mSubscriptionEstablished = YES; }
reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.GeneratedCommandList response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.GeneratedCommandList response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
@@ -174211,32 +174211,32 @@ class SubscribeAttributeSampleMeiGeneratedCommandList : public SubscribeAttribut
/*
* Attribute AcceptedCommandList
*/
-class ReadSampleMeiAcceptedCommandList : public ReadAttribute {
+class ReadSampleManufacturerSpecificAcceptedCommandList : public ReadAttribute {
public:
- ReadSampleMeiAcceptedCommandList()
+ ReadSampleManufacturerSpecificAcceptedCommandList()
: ReadAttribute("accepted-command-list")
{
}
- ~ReadSampleMeiAcceptedCommandList()
+ ~ReadSampleManufacturerSpecificAcceptedCommandList()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::AcceptedCommandList::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::AcceptedCommandList::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
[cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.AcceptedCommandList response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.AcceptedCommandList response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
- LogNSError("SampleMEI AcceptedCommandList read Error", error);
+ LogNSError("SampleManufacturerSpecific AcceptedCommandList read Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174245,25 +174245,25 @@ class ReadSampleMeiAcceptedCommandList : public ReadAttribute {
}
};
-class SubscribeAttributeSampleMeiAcceptedCommandList : public SubscribeAttribute {
+class SubscribeAttributeSampleManufacturerSpecificAcceptedCommandList : public SubscribeAttribute {
public:
- SubscribeAttributeSampleMeiAcceptedCommandList()
+ SubscribeAttributeSampleManufacturerSpecificAcceptedCommandList()
: SubscribeAttribute("accepted-command-list")
{
}
- ~SubscribeAttributeSampleMeiAcceptedCommandList()
+ ~SubscribeAttributeSampleManufacturerSpecificAcceptedCommandList()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId attributeId = chip::app::Clusters::SampleMei::Attributes::AcceptedCommandList::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::AcceptedCommandList::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
if (mKeepSubscriptions.HasValue()) {
params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
@@ -174277,7 +174277,7 @@ class SubscribeAttributeSampleMeiAcceptedCommandList : public SubscribeAttribute
[cluster subscribeAttributeAcceptedCommandListWithParams:params
subscriptionEstablished:^() { mSubscriptionEstablished = YES; }
reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.AcceptedCommandList response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.AcceptedCommandList response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
@@ -174296,32 +174296,32 @@ class SubscribeAttributeSampleMeiAcceptedCommandList : public SubscribeAttribute
/*
* Attribute AttributeList
*/
-class ReadSampleMeiAttributeList : public ReadAttribute {
+class ReadSampleManufacturerSpecificAttributeList : public ReadAttribute {
public:
- ReadSampleMeiAttributeList()
+ ReadSampleManufacturerSpecificAttributeList()
: ReadAttribute("attribute-list")
{
}
- ~ReadSampleMeiAttributeList()
+ ~ReadSampleManufacturerSpecificAttributeList()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::AttributeList::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::AttributeList::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
[cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.AttributeList response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.AttributeList response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
- LogNSError("SampleMEI AttributeList read Error", error);
+ LogNSError("SampleManufacturerSpecific AttributeList read Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174330,25 +174330,25 @@ class ReadSampleMeiAttributeList : public ReadAttribute {
}
};
-class SubscribeAttributeSampleMeiAttributeList : public SubscribeAttribute {
+class SubscribeAttributeSampleManufacturerSpecificAttributeList : public SubscribeAttribute {
public:
- SubscribeAttributeSampleMeiAttributeList()
+ SubscribeAttributeSampleManufacturerSpecificAttributeList()
: SubscribeAttribute("attribute-list")
{
}
- ~SubscribeAttributeSampleMeiAttributeList()
+ ~SubscribeAttributeSampleManufacturerSpecificAttributeList()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId attributeId = chip::app::Clusters::SampleMei::Attributes::AttributeList::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::AttributeList::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
if (mKeepSubscriptions.HasValue()) {
params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
@@ -174362,7 +174362,7 @@ class SubscribeAttributeSampleMeiAttributeList : public SubscribeAttribute {
[cluster subscribeAttributeAttributeListWithParams:params
subscriptionEstablished:^() { mSubscriptionEstablished = YES; }
reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.AttributeList response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.AttributeList response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
@@ -174381,32 +174381,32 @@ class SubscribeAttributeSampleMeiAttributeList : public SubscribeAttribute {
/*
* Attribute FeatureMap
*/
-class ReadSampleMeiFeatureMap : public ReadAttribute {
+class ReadSampleManufacturerSpecificFeatureMap : public ReadAttribute {
public:
- ReadSampleMeiFeatureMap()
+ ReadSampleManufacturerSpecificFeatureMap()
: ReadAttribute("feature-map")
{
}
- ~ReadSampleMeiFeatureMap()
+ ~ReadSampleManufacturerSpecificFeatureMap()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::FeatureMap::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::FeatureMap::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
[cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.FeatureMap response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.FeatureMap response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
- LogNSError("SampleMEI FeatureMap read Error", error);
+ LogNSError("SampleManufacturerSpecific FeatureMap read Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174415,25 +174415,25 @@ class ReadSampleMeiFeatureMap : public ReadAttribute {
}
};
-class SubscribeAttributeSampleMeiFeatureMap : public SubscribeAttribute {
+class SubscribeAttributeSampleManufacturerSpecificFeatureMap : public SubscribeAttribute {
public:
- SubscribeAttributeSampleMeiFeatureMap()
+ SubscribeAttributeSampleManufacturerSpecificFeatureMap()
: SubscribeAttribute("feature-map")
{
}
- ~SubscribeAttributeSampleMeiFeatureMap()
+ ~SubscribeAttributeSampleManufacturerSpecificFeatureMap()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId attributeId = chip::app::Clusters::SampleMei::Attributes::FeatureMap::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::FeatureMap::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
if (mKeepSubscriptions.HasValue()) {
params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
@@ -174447,7 +174447,7 @@ class SubscribeAttributeSampleMeiFeatureMap : public SubscribeAttribute {
[cluster subscribeAttributeFeatureMapWithParams:params
subscriptionEstablished:^() { mSubscriptionEstablished = YES; }
reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.FeatureMap response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.FeatureMap response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
@@ -174466,32 +174466,32 @@ class SubscribeAttributeSampleMeiFeatureMap : public SubscribeAttribute {
/*
* Attribute ClusterRevision
*/
-class ReadSampleMeiClusterRevision : public ReadAttribute {
+class ReadSampleManufacturerSpecificClusterRevision : public ReadAttribute {
public:
- ReadSampleMeiClusterRevision()
+ ReadSampleManufacturerSpecificClusterRevision()
: ReadAttribute("cluster-revision")
{
}
- ~ReadSampleMeiClusterRevision()
+ ~ReadSampleManufacturerSpecificClusterRevision()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleMei::Attributes::ClusterRevision::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::AttributeId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::ClusterRevision::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
[cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.ClusterRevision response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.ClusterRevision response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
- LogNSError("SampleMEI ClusterRevision read Error", error);
+ LogNSError("SampleManufacturerSpecific ClusterRevision read Error", error);
RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error);
}
SetCommandExitStatus(error);
@@ -174500,25 +174500,25 @@ class ReadSampleMeiClusterRevision : public ReadAttribute {
}
};
-class SubscribeAttributeSampleMeiClusterRevision : public SubscribeAttribute {
+class SubscribeAttributeSampleManufacturerSpecificClusterRevision : public SubscribeAttribute {
public:
- SubscribeAttributeSampleMeiClusterRevision()
+ SubscribeAttributeSampleManufacturerSpecificClusterRevision()
: SubscribeAttribute("cluster-revision")
{
}
- ~SubscribeAttributeSampleMeiClusterRevision()
+ ~SubscribeAttributeSampleManufacturerSpecificClusterRevision()
{
}
CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
{
- constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
- constexpr chip::CommandId attributeId = chip::app::Clusters::SampleMei::Attributes::ClusterRevision::Id;
+ constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleManufacturerSpecific::Id;
+ constexpr chip::CommandId attributeId = chip::app::Clusters::SampleManufacturerSpecific::Attributes::ClusterRevision::Id;
ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId);
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
- __auto_type * cluster = [[MTRBaseClusterSampleMEI alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
+ __auto_type * cluster = [[MTRBaseClusterSampleManufacturerSpecific alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue];
__auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
if (mKeepSubscriptions.HasValue()) {
params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
@@ -174532,7 +174532,7 @@ class SubscribeAttributeSampleMeiClusterRevision : public SubscribeAttribute {
[cluster subscribeAttributeClusterRevisionWithParams:params
subscriptionEstablished:^() { mSubscriptionEstablished = YES; }
reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
- NSLog(@"SampleMEI.ClusterRevision response %@", [value description]);
+ NSLog(@"SampleManufacturerSpecific.ClusterRevision response %@", [value description]);
if (error == nil) {
RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value);
} else {
@@ -181349,48 +181349,48 @@ void registerClusterUnitTesting(Commands & commands)
commands.RegisterCluster(clusterName, clusterCommands);
}
-void registerClusterSampleMei(Commands & commands)
+void registerClusterSampleManufacturerSpecific(Commands & commands)
{
#if MTR_ENABLE_PROVISIONAL
- using namespace chip::app::Clusters::SampleMei;
+ using namespace chip::app::Clusters::SampleManufacturerSpecific;
- const char * clusterName = "SampleMei";
+ const char * clusterName = "SampleManufacturerSpecific";
commands_list clusterCommands = {
make_unique<ClusterCommand>(Id), //
#if MTR_ENABLE_PROVISIONAL
- make_unique<SampleMeiPing>(), //
+ make_unique<SampleManufacturerSpecificPing>(), //
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
- make_unique<SampleMeiAddArguments>(), //
+ make_unique<SampleManufacturerSpecificAddArguments>(), //
#endif // MTR_ENABLE_PROVISIONAL
make_unique<ReadAttribute>(Id), //
make_unique<WriteAttribute>(Id), //
make_unique<SubscribeAttribute>(Id), //
#if MTR_ENABLE_PROVISIONAL
- make_unique<ReadSampleMeiFlipFlop>(), //
- make_unique<WriteSampleMeiFlipFlop>(), //
- make_unique<SubscribeAttributeSampleMeiFlipFlop>(), //
+ make_unique<ReadSampleManufacturerSpecificFlipFlop>(), //
+ make_unique<WriteSampleManufacturerSpecificFlipFlop>(), //
+ make_unique<SubscribeAttributeSampleManufacturerSpecificFlipFlop>(), //
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
- make_unique<ReadSampleMeiGeneratedCommandList>(), //
- make_unique<SubscribeAttributeSampleMeiGeneratedCommandList>(), //
+ make_unique<ReadSampleManufacturerSpecificGeneratedCommandList>(), //
+ make_unique<SubscribeAttributeSampleManufacturerSpecificGeneratedCommandList>(), //
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
- make_unique<ReadSampleMeiAcceptedCommandList>(), //
- make_unique<SubscribeAttributeSampleMeiAcceptedCommandList>(), //
+ make_unique<ReadSampleManufacturerSpecificAcceptedCommandList>(), //
+ make_unique<SubscribeAttributeSampleManufacturerSpecificAcceptedCommandList>(), //
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
- make_unique<ReadSampleMeiAttributeList>(), //
- make_unique<SubscribeAttributeSampleMeiAttributeList>(), //
+ make_unique<ReadSampleManufacturerSpecificAttributeList>(), //
+ make_unique<SubscribeAttributeSampleManufacturerSpecificAttributeList>(), //
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
- make_unique<ReadSampleMeiFeatureMap>(), //
- make_unique<SubscribeAttributeSampleMeiFeatureMap>(), //
+ make_unique<ReadSampleManufacturerSpecificFeatureMap>(), //
+ make_unique<SubscribeAttributeSampleManufacturerSpecificFeatureMap>(), //
#endif // MTR_ENABLE_PROVISIONAL
#if MTR_ENABLE_PROVISIONAL
- make_unique<ReadSampleMeiClusterRevision>(), //
- make_unique<SubscribeAttributeSampleMeiClusterRevision>(), //
+ make_unique<ReadSampleManufacturerSpecificClusterRevision>(), //
+ make_unique<SubscribeAttributeSampleManufacturerSpecificClusterRevision>(), //
#endif // MTR_ENABLE_PROVISIONAL
make_unique<ReadEvent>(Id), //
make_unique<SubscribeEvent>(Id), //
@@ -181543,5 +181543,5 @@ void registerClusters(Commands & commands)
registerClusterEcosystemInformation(commands);
registerClusterCommissionerControl(commands);
registerClusterUnitTesting(commands);
- registerClusterSampleMei(commands);
+ registerClusterSampleManufacturerSpecific(commands);
}